}
+/**
+ * Exposes the state of pending inbound HTLCs.
+ *
+ * At a high level, an HTLC being forwarded from one Lightning node to another Lightning node goes
+ * through the following states in the state machine:
+ * - Announced for addition by the originating node through the update_add_htlc message.
+ * - Added to the commitment transaction of the receiving node and originating node in turn
+ * through the exchange of commitment_signed and revoke_and_ack messages.
+ * - Announced for resolution (fulfillment or failure) by the receiving node through either one of
+ * the update_fulfill_htlc, update_fail_htlc, and update_fail_malformed_htlc messages.
+ * - Removed from the commitment transaction of the originating node and receiving node in turn
+ * through the exchange of commitment_signed and revoke_and_ack messages.
+ *
+ * This can be used to inspect what next message an HTLC is waiting for to advance its state.
+ */
+export enum InboundHTLCStateDetails {
+ /**
+ * We have added this HTLC in our commitment transaction by receiving commitment_signed and
+ returning revoke_and_ack. We are awaiting the appropriate revoke_and_ack's from the remote
+ before this HTLC is included on the remote commitment transaction.
+ */
+ LDKInboundHTLCStateDetails_AwaitingRemoteRevokeToAdd,
+ /**
+ * This HTLC has been included in the commitment_signed and revoke_and_ack messages on both sides
+ and is included in both commitment transactions.
+
+ This HTLC is now safe to either forward or be claimed as a payment by us. The HTLC will
+ remain in this state until the forwarded upstream HTLC has been resolved and we resolve this
+ HTLC correspondingly, or until we claim it as a payment. If it is part of a multipart
+ payment, it will only be claimed together with other required parts.
+ */
+ LDKInboundHTLCStateDetails_Committed,
+ /**
+ * We have received the preimage for this HTLC and it is being removed by fulfilling it with
+ update_fulfill_htlc. This HTLC is still on both commitment transactions, but we are awaiting
+ the appropriate revoke_and_ack's from the remote before this HTLC is removed from the remote
+ commitment transaction after update_fulfill_htlc.
+ */
+ LDKInboundHTLCStateDetails_AwaitingRemoteRevokeToRemoveFulfill,
+ /**
+ * The HTLC is being removed by failing it with update_fail_htlc or update_fail_malformed_htlc.
+ This HTLC is still on both commitment transactions, but we are awaiting the appropriate
+ revoke_and_ack's from the remote before this HTLC is removed from the remote commitment
+ transaction.
+ */
+ LDKInboundHTLCStateDetails_AwaitingRemoteRevokeToRemoveFail,
+
+}
+
/**
* An enum representing the available verbosity levels of the logger.
*/
}
+/**
+ * Exposes the state of pending outbound HTLCs.
+ *
+ * At a high level, an HTLC being forwarded from one Lightning node to another Lightning node goes
+ * through the following states in the state machine:
+ * - Announced for addition by the originating node through the update_add_htlc message.
+ * - Added to the commitment transaction of the receiving node and originating node in turn
+ * through the exchange of commitment_signed and revoke_and_ack messages.
+ * - Announced for resolution (fulfillment or failure) by the receiving node through either one of
+ * the update_fulfill_htlc, update_fail_htlc, and update_fail_malformed_htlc messages.
+ * - Removed from the commitment transaction of the originating node and receiving node in turn
+ * through the exchange of commitment_signed and revoke_and_ack messages.
+ *
+ * This can be used to inspect what next message an HTLC is waiting for to advance its state.
+ */
+export enum OutboundHTLCStateDetails {
+ /**
+ * We are awaiting the appropriate revoke_and_ack's from the remote before the HTLC is added
+ on the remote's commitment transaction after update_add_htlc.
+ */
+ LDKOutboundHTLCStateDetails_AwaitingRemoteRevokeToAdd,
+ /**
+ * The HTLC has been added to the remote's commitment transaction by sending commitment_signed
+ and receiving revoke_and_ack in return.
+
+ The HTLC will remain in this state until the remote node resolves the HTLC, or until we
+ unilaterally close the channel due to a timeout with an uncooperative remote node.
+ */
+ LDKOutboundHTLCStateDetails_Committed,
+ /**
+ * The HTLC has been fulfilled successfully by the remote with a preimage in update_fulfill_htlc,
+ and we removed the HTLC from our commitment transaction by receiving commitment_signed and
+ returning revoke_and_ack. We are awaiting the appropriate revoke_and_ack's from the remote
+ for the removal from its commitment transaction.
+ */
+ LDKOutboundHTLCStateDetails_AwaitingRemoteRevokeToRemoveSuccess,
+ /**
+ * The HTLC has been failed by the remote with update_fail_htlc or update_fail_malformed_htlc,
+ and we removed the HTLC from our commitment transaction by receiving commitment_signed and
+ returning revoke_and_ack. We are awaiting the appropriate revoke_and_ack's from the remote
+ for the removal from its commitment transaction.
+ */
+ LDKOutboundHTLCStateDetails_AwaitingRemoteRevokeToRemoveFailure,
+
+}
+
/**
* The reason the payment failed. Used in [`Event::PaymentFailed`].
*/
}
const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(ptr);
return nativeResponseValue;
-}
-/* @internal */
-export class LDKCOption_ChannelShutdownStateZ {
- protected constructor() {}
-}
-/* @internal */
-export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
- return nativeResponseValue;
-}
-/* @internal */
-export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
- return nativeResponseValue;
}
// struct LDKChannelId CResult_ChannelIdAPIErrorZ_get_ok(LDKCResult_ChannelIdAPIErrorZ *NONNULL_PTR owner);
/* @internal */
}
const nativeResponseValue = wasm.TS_C3Tuple_OffersMessageDestinationBlindedPathZ_get_c(owner);
return nativeResponseValue;
-}
- // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
- return nativeResponseValue;
-}
- // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
- return nativeResponseValue;
-}
- // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
- return nativeResponseValue;
-}
- // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
- return nativeResponseValue;
-}
- // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
- return nativeResponseValue;
-}
- // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
- return nativeResponseValue;
}
// struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
/* @internal */
}
const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_get_err(owner);
return nativeResponseValue;
-}
- // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
- return nativeResponseValue;
-}
- // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
- return nativeResponseValue;
}
/* @internal */
export interface LDKWatch {
}
const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner);
return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_InboundHTLCStateDetailsZ {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_InboundHTLCStateDetailsZ_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKCOption_InboundHTLCStateDetailsZ_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_InboundHTLCStateDetailsZ_Some_get_some(ptr: bigint): InboundHTLCStateDetails {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKCOption_InboundHTLCStateDetailsZ_Some_get_some(ptr);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_InboundHTLCStateDetailsZ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_get_ok(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_get_err(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+ // struct LDKInboundHTLCDetails CResult_InboundHTLCDetailsDecodeErrorZ_get_ok(LDKCResult_InboundHTLCDetailsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_InboundHTLCDetailsDecodeErrorZ_get_err(LDKCResult_InboundHTLCDetailsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_OutboundHTLCStateDetailsZ {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_OutboundHTLCStateDetailsZ_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKCOption_OutboundHTLCStateDetailsZ_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_OutboundHTLCStateDetailsZ_Some_get_some(ptr: bigint): OutboundHTLCStateDetails {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKCOption_OutboundHTLCStateDetailsZ_Some_get_some(ptr);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_OutboundHTLCStateDetailsZ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_get_ok(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_get_err(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+ // struct LDKOutboundHTLCDetails CResult_OutboundHTLCDetailsDecodeErrorZ_get_ok(LDKCResult_OutboundHTLCDetailsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_OutboundHTLCDetailsDecodeErrorZ_get_err(LDKCResult_OutboundHTLCDetailsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+ // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+ // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+/* @internal */
+export class LDKCOption_ChannelShutdownStateZ {
+ protected constructor() {}
+}
+/* @internal */
+export function LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(ptr);
+ return nativeResponseValue;
+}
+/* @internal */
+export function LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr: bigint): ChannelShutdownState {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(ptr);
+ return nativeResponseValue;
+}
+ // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
+}
+ // enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner: bigint): ChannelShutdownState {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner);
+ return nativeResponseValue;
+}
+ // struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner);
+ return nativeResponseValue;
}
// struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner);
/* @internal */
}
const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u16ZZ_clone(orig);
return nativeResponseValue;
-}
- // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
-/* @internal */
-export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
- return nativeResponseValue;
-}
- // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
-/* @internal */
-export function COption_ChannelShutdownStateZ_none(): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
- return nativeResponseValue;
-}
- // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
-/* @internal */
-export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
- // debug statements here
-}
- // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
-/* @internal */
-export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
- return nativeResponseValue;
-}
- // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
-/* @internal */
-export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
- return nativeResponseValue;
}
// struct LDKCResult_ChannelIdAPIErrorZ CResult_ChannelIdAPIErrorZ_ok(struct LDKChannelId o);
/* @internal */
}
const nativeResponseValue = wasm.TS_CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(_res);
// debug statements here
-}
- // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
- return nativeResponseValue;
-}
- // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
- return nativeResponseValue;
-}
- // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
- return nativeResponseValue;
-}
- // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
- // debug statements here
-}
- // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
- return nativeResponseValue;
-}
- // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
- return nativeResponseValue;
-}
- // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
- return nativeResponseValue;
-}
- // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
- // debug statements here
-}
- // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
- return nativeResponseValue;
-}
- // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
- return nativeResponseValue;
-}
- // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
- // debug statements here
-}
- // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
- return nativeResponseValue;
}
// struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
/* @internal */
}
const nativeResponseValue = wasm.TS_CResult_BlindedFailureDecodeErrorZ_clone(orig);
return nativeResponseValue;
-}
- // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
- return nativeResponseValue;
-}
- // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
- return nativeResponseValue;
-}
- // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
- // debug statements here
-}
- // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
- return nativeResponseValue;
-}
- // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
-/* @internal */
-export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
- return nativeResponseValue;
}
// void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
/* @internal */
}
const nativeResponseValue = wasm.TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig);
return nativeResponseValue;
+}
+ // struct LDKCOption_InboundHTLCStateDetailsZ COption_InboundHTLCStateDetailsZ_some(enum LDKInboundHTLCStateDetails o);
+/* @internal */
+export function COption_InboundHTLCStateDetailsZ_some(o: InboundHTLCStateDetails): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_InboundHTLCStateDetailsZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_InboundHTLCStateDetailsZ COption_InboundHTLCStateDetailsZ_none(void);
+/* @internal */
+export function COption_InboundHTLCStateDetailsZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_InboundHTLCStateDetailsZ_none();
+ return nativeResponseValue;
+}
+ // void COption_InboundHTLCStateDetailsZ_free(struct LDKCOption_InboundHTLCStateDetailsZ _res);
+/* @internal */
+export function COption_InboundHTLCStateDetailsZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_InboundHTLCStateDetailsZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_InboundHTLCStateDetailsZ_clone_ptr(LDKCOption_InboundHTLCStateDetailsZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_InboundHTLCStateDetailsZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_InboundHTLCStateDetailsZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_InboundHTLCStateDetailsZ COption_InboundHTLCStateDetailsZ_clone(const struct LDKCOption_InboundHTLCStateDetailsZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_InboundHTLCStateDetailsZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_InboundHTLCStateDetailsZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_ok(struct LDKCOption_InboundHTLCStateDetailsZ o);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ _res);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_clone_ptr(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_clone(const struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InboundHTLCDetailsDecodeErrorZ CResult_InboundHTLCDetailsDecodeErrorZ_ok(struct LDKInboundHTLCDetails o);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InboundHTLCDetailsDecodeErrorZ CResult_InboundHTLCDetailsDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_InboundHTLCDetailsDecodeErrorZ_is_ok(const struct LDKCResult_InboundHTLCDetailsDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_InboundHTLCDetailsDecodeErrorZ_free(struct LDKCResult_InboundHTLCDetailsDecodeErrorZ _res);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_InboundHTLCDetailsDecodeErrorZ_clone_ptr(LDKCResult_InboundHTLCDetailsDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_InboundHTLCDetailsDecodeErrorZ CResult_InboundHTLCDetailsDecodeErrorZ_clone(const struct LDKCResult_InboundHTLCDetailsDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_InboundHTLCDetailsDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_InboundHTLCDetailsDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_OutboundHTLCStateDetailsZ COption_OutboundHTLCStateDetailsZ_some(enum LDKOutboundHTLCStateDetails o);
+/* @internal */
+export function COption_OutboundHTLCStateDetailsZ_some(o: OutboundHTLCStateDetails): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_OutboundHTLCStateDetailsZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_OutboundHTLCStateDetailsZ COption_OutboundHTLCStateDetailsZ_none(void);
+/* @internal */
+export function COption_OutboundHTLCStateDetailsZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_OutboundHTLCStateDetailsZ_none();
+ return nativeResponseValue;
+}
+ // void COption_OutboundHTLCStateDetailsZ_free(struct LDKCOption_OutboundHTLCStateDetailsZ _res);
+/* @internal */
+export function COption_OutboundHTLCStateDetailsZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_OutboundHTLCStateDetailsZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_OutboundHTLCStateDetailsZ_clone_ptr(LDKCOption_OutboundHTLCStateDetailsZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_OutboundHTLCStateDetailsZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_OutboundHTLCStateDetailsZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_OutboundHTLCStateDetailsZ COption_OutboundHTLCStateDetailsZ_clone(const struct LDKCOption_OutboundHTLCStateDetailsZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_OutboundHTLCStateDetailsZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_OutboundHTLCStateDetailsZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_ok(struct LDKCOption_OutboundHTLCStateDetailsZ o);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_is_ok(const struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ _res);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_clone_ptr(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_clone(const struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ CResult_OutboundHTLCDetailsDecodeErrorZ_ok(struct LDKOutboundHTLCDetails o);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ CResult_OutboundHTLCDetailsDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_OutboundHTLCDetailsDecodeErrorZ_is_ok(const struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_OutboundHTLCDetailsDecodeErrorZ_free(struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ _res);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_OutboundHTLCDetailsDecodeErrorZ_clone_ptr(LDKCResult_OutboundHTLCDetailsDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ CResult_OutboundHTLCDetailsDecodeErrorZ_clone(const struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_OutboundHTLCDetailsDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutboundHTLCDetailsDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_some(enum LDKChannelShutdownState o);
+/* @internal */
+export function COption_ChannelShutdownStateZ_some(o: ChannelShutdownState): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_none(void);
+/* @internal */
+export function COption_ChannelShutdownStateZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_none();
+ return nativeResponseValue;
+}
+ // void COption_ChannelShutdownStateZ_free(struct LDKCOption_ChannelShutdownStateZ _res);
+/* @internal */
+export function COption_ChannelShutdownStateZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_free(_res);
+ // debug statements here
+}
+ // uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg);
+/* @internal */
+export function COption_ChannelShutdownStateZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_ChannelShutdownStateZ COption_ChannelShutdownStateZ_clone(const struct LDKCOption_ChannelShutdownStateZ *NONNULL_PTR orig);
+/* @internal */
+export function COption_ChannelShutdownStateZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_ChannelShutdownStateZ_clone(orig);
+ return nativeResponseValue;
+}
+ // void CVec_InboundHTLCDetailsZ_free(struct LDKCVec_InboundHTLCDetailsZ _res);
+/* @internal */
+export function CVec_InboundHTLCDetailsZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_InboundHTLCDetailsZ_free(_res);
+ // debug statements here
+}
+ // void CVec_OutboundHTLCDetailsZ_free(struct LDKCVec_OutboundHTLCDetailsZ _res);
+/* @internal */
+export function CVec_OutboundHTLCDetailsZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_OutboundHTLCDetailsZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_ok(enum LDKChannelShutdownState o);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_ok(o: ChannelShutdownState): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_ChannelShutdownStateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_ChannelShutdownStateDecodeErrorZ_free(struct LDKCResult_ChannelShutdownStateDecodeErrorZ _res);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelShutdownStateDecodeErrorZ CResult_ChannelShutdownStateDecodeErrorZ_clone(const struct LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_ChannelShutdownStateDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
}
// struct LDKCResult_OffersMessageDecodeErrorZ CResult_OffersMessageDecodeErrorZ_ok(struct LDKOffersMessage o);
/* @internal */
}
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 */
}
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 */
}
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 */
}
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 */
}
const nativeResponseValue = wasm.TS_OutPoint_hash(o);
return nativeResponseValue;
+}
+ // struct LDKStr OutPoint_to_str(const struct LDKOutPoint *NONNULL_PTR o);
+/* @internal */
+export function OutPoint_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutPoint_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
/* @internal */
const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
return nativeResponseValue;
}
- // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
+ // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
/* @internal */
-export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
+export function RecentPaymentDetails_free(this_ptr: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
// debug statements here
}
- // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
+ // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
/* @internal */
-export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
+export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
return nativeResponseValue;
}
- // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
-/* @internal */
-export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
- // debug statements here
-}
- // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
+ // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
/* @internal */
-export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
+export function RecentPaymentDetails_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
return nativeResponseValue;
}
- // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
+ // struct LDKRecentPaymentDetails RecentPaymentDetails_awaiting_invoice(struct LDKThirtyTwoBytes payment_id);
/* @internal */
-export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
+export function RecentPaymentDetails_awaiting_invoice(payment_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_awaiting_invoice(payment_id);
+ return nativeResponseValue;
}
- // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
+ // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
/* @internal */
-export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
+export function RecentPaymentDetails_pending(payment_id: number, payment_hash: number, total_msat: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_id, payment_hash, total_msat);
return nativeResponseValue;
}
- // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
+ // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash);
/* @internal */
-export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
+export function RecentPaymentDetails_fulfilled(payment_id: number, payment_hash: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_id, payment_hash);
+ return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_new(uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg);
+ // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
/* @internal */
-export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
+export function RecentPaymentDetails_abandoned(payment_id: number, payment_hash: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
+ const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_id, payment_hash);
return nativeResponseValue;
}
- // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
+ // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
/* @internal */
-export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
+export function PhantomRouteHints_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
+ // debug statements here
}
- // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
+ // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
/* @internal */
-export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
+export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
return nativeResponseValue;
}
- // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
+ // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
/* @internal */
-export function ChannelCounterparty_free(this_obj: bigint): void {
+export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
+export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
return nativeResponseValue;
}
- // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
+export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
// debug statements here
}
- // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
+export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
return nativeResponseValue;
}
- // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
+ // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
/* @internal */
-export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
+export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
// debug statements here
}
- // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
/* @internal */
-export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
+export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
return nativeResponseValue;
}
- // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
-/* @internal */
-export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
- // debug statements here
-}
- // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
/* @internal */
-export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
+export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
return nativeResponseValue;
}
- // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
+ // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
/* @internal */
-export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
+export function PhantomRouteHints_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKUserConfig config, struct LDKChainParameters params, uint32_t current_timestamp);
/* @internal */
-export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
+export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, entropy_source: bigint, node_signer: bigint, signer_provider: bigint, config: bigint, params: bigint, current_timestamp: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
return nativeResponseValue;
}
- // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
+ return nativeResponseValue;
}
- // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_ChannelIdAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, struct LDKU128 user_channel_id, struct LDKChannelId temporary_channel_id, struct LDKUserConfig override_config);
/* @internal */
-export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
+export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, temporary_channel_id: bigint, override_config: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, temporary_channel_id, override_config);
return nativeResponseValue;
}
- // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_list_channels(this_arg: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
+ return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelCounterparty ChannelCounterparty_new(struct LDKPublicKey node_id_arg, struct LDKInitFeatures features_arg, uint64_t unspendable_punishment_reserve_arg, struct LDKCounterpartyForwardingInfo forwarding_info_arg, struct LDKCOption_u64Z outbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z outbound_htlc_maximum_msat_arg);
+ // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelCounterparty_new(node_id_arg: number, features_arg: bigint, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: bigint, outbound_htlc_minimum_msat_arg: bigint, outbound_htlc_maximum_msat_arg: bigint): bigint {
+export function ChannelManager_list_usable_channels(this_arg: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg, outbound_htlc_minimum_msat_arg, outbound_htlc_maximum_msat_arg);
+ const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
return nativeResponseValue;
}
- // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
+ // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
/* @internal */
-export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
+export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
return nativeResponseValue;
}
- // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
+ // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelCounterparty_clone(orig: bigint): bigint {
+export function ChannelManager_list_recent_payments(this_arg: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
+ const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_free(struct LDKChannelDetails this_obj);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
/* @internal */
-export function ChannelDetails_free(this_obj: bigint): void {
+export function ChannelManager_close_channel(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
+ return nativeResponseValue;
}
- // struct LDKChannelId ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_feerate_and_script(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id, struct LDKCOption_u32Z target_feerate_sats_per_1000_weight, struct LDKShutdownScript shutdown_script);
/* @internal */
-export function ChannelDetails_get_channel_id(this_ptr: bigint): bigint {
+export function ChannelManager_close_channel_with_feerate_and_script(this_arg: bigint, channel_id: bigint, counterparty_node_id: number, target_feerate_sats_per_1000_weight: bigint, shutdown_script: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_feerate_and_script(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight, shutdown_script);
return nativeResponseValue;
}
- // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelId val);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
/* @internal */
-export function ChannelDetails_set_channel_id(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
+ return nativeResponseValue;
}
- // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
/* @internal */
-export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
+export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
return nativeResponseValue;
}
- // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
+ // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
// debug statements here
}
- // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
+export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
+ // debug statements here
}
- // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+ // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment_with_route(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
/* @internal */
-export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
+ return nativeResponseValue;
}
- // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
/* @internal */
-export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
+export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
return nativeResponseValue;
}
- // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
+ // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
/* @internal */
-export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
// debug statements here
}
- // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
/* @internal */
-export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
+export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
return nativeResponseValue;
}
- // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
/* @internal */
-export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
+ return nativeResponseValue;
}
- // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
/* @internal */
-export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
+export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
return nativeResponseValue;
}
- // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_spontaneous_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, uint64_t amount_msat, uint32_t final_cltv_expiry_delta, struct LDKCOption_u64Z liquidity_limit_multiplier);
/* @internal */
-export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_send_spontaneous_preflight_probes(this_arg: bigint, node_id: number, amount_msat: bigint, final_cltv_expiry_delta: number, liquidity_limit_multiplier: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_preflight_probes(this_arg, node_id, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier);
+ return nativeResponseValue;
}
- // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKRouteParameters route_params, struct LDKCOption_u64Z liquidity_limit_multiplier);
/* @internal */
-export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
+export function ChannelManager_send_preflight_probes(this_arg: bigint, route_params: bigint, liquidity_limit_multiplier: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_send_preflight_probes(this_arg, route_params, liquidity_limit_multiplier);
return nativeResponseValue;
}
- // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
/* @internal */
-export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, funding_transaction: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
+ return nativeResponseValue;
}
- // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_batch_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_ChannelIdPublicKeyZZ temporary_channels, struct LDKTransaction funding_transaction);
/* @internal */
-export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
+export function ChannelManager_batch_funding_transaction_generated(this_arg: bigint, temporary_channels: number, funding_transaction: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_batch_funding_transaction_generated(this_arg, temporary_channels, funding_transaction);
return nativeResponseValue;
}
- // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_partial_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ChannelIdZ channel_ids, const struct LDKChannelConfigUpdate *NONNULL_PTR config_update);
/* @internal */
-export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
+ return nativeResponseValue;
}
- // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ChannelIdZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
/* @internal */
-export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
+export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
return nativeResponseValue;
}
- // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_forward_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id, const struct LDKChannelId *NONNULL_PTR next_hop_channel_id, struct LDKPublicKey next_node_id, uint64_t amt_to_forward_msat);
/* @internal */
-export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_forward_intercepted_htlc(this_arg: bigint, intercept_id: number, next_hop_channel_id: bigint, next_node_id: number, amt_to_forward_msat: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
+ return nativeResponseValue;
}
- // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
/* @internal */
-export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
+export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
return nativeResponseValue;
}
- // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
+ // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
+export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
// debug statements here
}
- // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
+export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
+ // debug statements here
}
- // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+ // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
/* @internal */
-export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
// debug statements here
}
- // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKFailureCode failure_code);
/* @internal */
-export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
+export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
+ // debug statements here
}
- // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
/* @internal */
-export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
// debug statements here
}
- // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // void ChannelManager_claim_funds_with_known_custom_tlvs(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
/* @internal */
-export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
+export function ChannelManager_claim_funds_with_known_custom_tlvs(this_arg: bigint, payment_preimage: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelManager_claim_funds_with_known_custom_tlvs(this_arg, payment_preimage);
+ // debug statements here
}
- // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_get_our_node_id(this_arg: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
+ return nativeResponseValue;
}
- // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
/* @internal */
-export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
+export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, user_channel_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
return nativeResponseValue;
}
- // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
/* @internal */
-export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, user_channel_id: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
+ return nativeResponseValue;
}
- // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ ChannelManager_create_offer_builder(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
+export function ChannelManager_create_offer_builder(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_create_offer_builder(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ ChannelManager_create_refund_builder(const struct LDKChannelManager *NONNULL_PTR this_arg, uint64_t amount_msats, uint64_t absolute_expiry, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, struct LDKCOption_u64Z max_total_routing_fee_msat);
/* @internal */
-export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_create_refund_builder(this_arg: bigint, amount_msats: bigint, absolute_expiry: bigint, payment_id: number, retry_strategy: bigint, max_total_routing_fee_msat: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_create_refund_builder(this_arg, amount_msats, absolute_expiry, payment_id, retry_strategy, max_total_routing_fee_msat);
+ return nativeResponseValue;
}
- // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ ChannelManager_pay_for_offer(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKOffer *NONNULL_PTR offer, struct LDKCOption_u64Z quantity, struct LDKCOption_u64Z amount_msats, struct LDKCOption_StrZ payer_note, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, struct LDKCOption_u64Z max_total_routing_fee_msat);
/* @internal */
-export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
+export function ChannelManager_pay_for_offer(this_arg: bigint, offer: bigint, quantity: bigint, amount_msats: bigint, payer_note: bigint, payment_id: number, retry_strategy: bigint, max_total_routing_fee_msat: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_pay_for_offer(this_arg, offer, quantity, amount_msats, payer_note, payment_id, retry_strategy, max_total_routing_fee_msat);
return nativeResponseValue;
}
- // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
+ // MUST_USE_RES struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ ChannelManager_request_refund_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRefund *NONNULL_PTR refund);
/* @internal */
-export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_request_refund_payment(this_arg: bigint, refund: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_request_refund_payment(this_arg, refund);
+ return nativeResponseValue;
}
- // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ ChannelManager_create_inbound_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
/* @internal */
-export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
+export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
return nativeResponseValue;
}
- // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+ // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ ChannelManager_create_inbound_payment_for_hash(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry);
/* @internal */
-export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry);
+ return nativeResponseValue;
}
- // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesAPIErrorZ ChannelManager_get_payment_preimage(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
/* @internal */
-export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
+export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
return nativeResponseValue;
}
- // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+ // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
+ return nativeResponseValue;
}
- // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
+export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
+ // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
+ return nativeResponseValue;
}
- // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
+export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
+ // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
+export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
+ return nativeResponseValue;
}
- // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
+export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
+ // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
+export function ChannelManager_as_Listen(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
+ return nativeResponseValue;
}
- // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
+export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
+ // MUST_USE_RES struct LDKFuture ChannelManager_get_event_or_persistence_needed_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
+export function ChannelManager_get_event_or_persistence_needed_future(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManager_get_event_or_persistence_needed_future(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool ChannelManager_get_and_clear_needs_persistence(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_get_and_clear_needs_persistence(this_arg: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_get_and_clear_needs_persistence(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_current_best_block(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_node_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_channel_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_init_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKOffersMessageHandler ChannelManager_as_OffersMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_as_OffersMessageHandler(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_as_OffersMessageHandler(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKNodeIdLookUp ChannelManager_as_NodeIdLookUp(const struct LDKChannelManager *NONNULL_PTR this_arg);
+/* @internal */
+export function ChannelManager_as_NodeIdLookUp(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_as_NodeIdLookUp(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
+/* @internal */
+export function provided_init_features(config: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_provided_init_features(config);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
+/* @internal */
+export function PhantomRouteHints_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
+/* @internal */
+export function PhantomRouteHints_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z BlindedForward_write(const struct LDKBlindedForward *NONNULL_PTR obj);
+/* @internal */
+export function BlindedForward_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedForward_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedForwardDecodeErrorZ BlindedForward_read(struct LDKu8slice ser);
+/* @internal */
+export function BlindedForward_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedForward_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z PendingHTLCRouting_write(const struct LDKPendingHTLCRouting *NONNULL_PTR obj);
+/* @internal */
+export function PendingHTLCRouting_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PendingHTLCRouting_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ PendingHTLCRouting_read(struct LDKu8slice ser);
+/* @internal */
+export function PendingHTLCRouting_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PendingHTLCRouting_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z PendingHTLCInfo_write(const struct LDKPendingHTLCInfo *NONNULL_PTR obj);
+/* @internal */
+export function PendingHTLCInfo_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PendingHTLCInfo_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PendingHTLCInfoDecodeErrorZ PendingHTLCInfo_read(struct LDKu8slice ser);
+/* @internal */
+export function PendingHTLCInfo_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PendingHTLCInfo_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z BlindedFailure_write(const enum LDKBlindedFailure *NONNULL_PTR obj);
+/* @internal */
+export function BlindedFailure_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedFailure_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedFailureDecodeErrorZ BlindedFailure_read(struct LDKu8slice ser);
+/* @internal */
+export function BlindedFailure_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedFailure_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
+/* @internal */
+export function ChannelManager_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
+ return nativeResponseValue;
+}
+ // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
+/* @internal */
+export function ChannelManagerReadArgs_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
// debug statements here
}
- // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
+export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
+ // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
/* @internal */
-export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
+export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
// debug statements here
}
- // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
+export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
+ // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
/* @internal */
-export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
+export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
// debug statements here
}
- // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
+export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
/* @internal */
-export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
// debug statements here
}
- // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
+export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
/* @internal */
-export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
+export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
// debug statements here
}
- // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelDetails_get_config(this_ptr: bigint): bigint {
+export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
return nativeResponseValue;
}
- // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
+ // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
/* @internal */
-export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
+export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
// debug statements here
}
- // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
+ // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelDetails_clone_ptr(arg: bigint): bigint {
+export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
return nativeResponseValue;
}
- // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
+ // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
/* @internal */
-export function ChannelDetails_clone(orig: bigint): bigint {
+export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
+ // debug statements here
+}
+ // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
+ // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
/* @internal */
-export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
+export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
+ // debug statements here
+}
+ // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
+ // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
/* @internal */
-export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
+export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
return nativeResponseValue;
}
- // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
+ // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
/* @internal */
-export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
+export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
+/* @internal */
+export function ChannelManagerReadArgs_new(entropy_source: bigint, node_signer: bigint, signer_provider: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
return nativeResponseValue;
}
- // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
+ // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
/* @internal */
-export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
+export function C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser: number, arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
+ const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser, arg);
return nativeResponseValue;
}
- // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
+ // void DelayedPaymentBasepoint_free(struct LDKDelayedPaymentBasepoint this_obj);
/* @internal */
-export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
+export function DelayedPaymentBasepoint_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_free(this_obj);
+ // debug statements here
+}
+ // struct LDKPublicKey DelayedPaymentBasepoint_get_a(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr);
+/* @internal */
+export function DelayedPaymentBasepoint_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_get_a(this_ptr);
return nativeResponseValue;
}
- // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
+ // void DelayedPaymentBasepoint_set_a(struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
/* @internal */
-export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
+export function DelayedPaymentBasepoint_set_a(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_new(struct LDKPublicKey a_arg);
+/* @internal */
+export function DelayedPaymentBasepoint_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_new(a_arg);
return nativeResponseValue;
}
- // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
+ // bool DelayedPaymentBasepoint_eq(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR a, const struct LDKDelayedPaymentBasepoint *NONNULL_PTR b);
/* @internal */
-export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
+export function DelayedPaymentBasepoint_eq(a: bigint, b: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_eq(a, b);
return nativeResponseValue;
}
- // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
+ // uint64_t DelayedPaymentBasepoint_clone_ptr(LDKDelayedPaymentBasepoint *NONNULL_PTR arg);
/* @internal */
-export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
+export function DelayedPaymentBasepoint_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone_ptr(arg);
return nativeResponseValue;
}
- // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
+ // struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_clone(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR orig);
/* @internal */
-export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
+export function DelayedPaymentBasepoint_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone(orig);
return nativeResponseValue;
}
- // void RecentPaymentDetails_free(struct LDKRecentPaymentDetails this_ptr);
+ // uint64_t DelayedPaymentBasepoint_hash(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR o);
/* @internal */
-export function RecentPaymentDetails_free(this_ptr: bigint): void {
+export function DelayedPaymentBasepoint_hash(o: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_free(this_ptr);
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_hash(o);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey DelayedPaymentBasepoint_to_public_key(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg);
+/* @internal */
+export function DelayedPaymentBasepoint_to_public_key(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_to_public_key(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes DelayedPaymentBasepoint_derive_add_tweak(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg, struct LDKPublicKey per_commitment_point);
+/* @internal */
+export function DelayedPaymentBasepoint_derive_add_tweak(this_arg: bigint, per_commitment_point: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_derive_add_tweak(this_arg, per_commitment_point);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z DelayedPaymentBasepoint_write(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR obj);
+/* @internal */
+export function DelayedPaymentBasepoint_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ DelayedPaymentBasepoint_read(struct LDKu8slice ser);
+/* @internal */
+export function DelayedPaymentBasepoint_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_read(ser);
+ return nativeResponseValue;
+}
+ // void DelayedPaymentKey_free(struct LDKDelayedPaymentKey this_obj);
+/* @internal */
+export function DelayedPaymentKey_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_free(this_obj);
// debug statements here
}
- // uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg);
+ // struct LDKPublicKey DelayedPaymentKey_get_a(const struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr);
/* @internal */
-export function RecentPaymentDetails_clone_ptr(arg: bigint): bigint {
+export function DelayedPaymentKey_get_a(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_get_a(this_ptr);
return nativeResponseValue;
}
- // struct LDKRecentPaymentDetails RecentPaymentDetails_clone(const struct LDKRecentPaymentDetails *NONNULL_PTR orig);
+ // void DelayedPaymentKey_set_a(struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
/* @internal */
-export function RecentPaymentDetails_clone(orig: bigint): bigint {
+export function DelayedPaymentKey_set_a(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_clone(orig);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_new(struct LDKPublicKey a_arg);
+/* @internal */
+export function DelayedPaymentKey_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_new(a_arg);
return nativeResponseValue;
}
- // struct LDKRecentPaymentDetails RecentPaymentDetails_awaiting_invoice(struct LDKThirtyTwoBytes payment_id);
+ // bool DelayedPaymentKey_eq(const struct LDKDelayedPaymentKey *NONNULL_PTR a, const struct LDKDelayedPaymentKey *NONNULL_PTR b);
/* @internal */
-export function RecentPaymentDetails_awaiting_invoice(payment_id: number): bigint {
+export function DelayedPaymentKey_eq(a: bigint, b: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_awaiting_invoice(payment_id);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_eq(a, b);
return nativeResponseValue;
}
- // struct LDKRecentPaymentDetails RecentPaymentDetails_pending(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, uint64_t total_msat);
+ // uint64_t DelayedPaymentKey_clone_ptr(LDKDelayedPaymentKey *NONNULL_PTR arg);
/* @internal */
-export function RecentPaymentDetails_pending(payment_id: number, payment_hash: number, total_msat: bigint): bigint {
+export function DelayedPaymentKey_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_pending(payment_id, payment_hash, total_msat);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone_ptr(arg);
return nativeResponseValue;
}
- // struct LDKRecentPaymentDetails RecentPaymentDetails_fulfilled(struct LDKThirtyTwoBytes payment_id, struct LDKCOption_ThirtyTwoBytesZ payment_hash);
+ // struct LDKDelayedPaymentKey DelayedPaymentKey_clone(const struct LDKDelayedPaymentKey *NONNULL_PTR orig);
/* @internal */
-export function RecentPaymentDetails_fulfilled(payment_id: number, payment_hash: bigint): bigint {
+export function DelayedPaymentKey_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_fulfilled(payment_id, payment_hash);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone(orig);
return nativeResponseValue;
}
- // struct LDKRecentPaymentDetails RecentPaymentDetails_abandoned(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
+ // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_basepoint(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
/* @internal */
-export function RecentPaymentDetails_abandoned(payment_id: number, payment_hash: number): bigint {
+export function DelayedPaymentKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RecentPaymentDetails_abandoned(payment_id, payment_hash);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
return nativeResponseValue;
}
- // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
+ // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_secret_key(const uint8_t (*sk)[32]);
/* @internal */
-export function PhantomRouteHints_free(this_obj: bigint): void {
+export function DelayedPaymentKey_from_secret_key(sk: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_secret_key(sk);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey DelayedPaymentKey_to_public_key(const struct LDKDelayedPaymentKey *NONNULL_PTR this_arg);
+/* @internal */
+export function DelayedPaymentKey_to_public_key(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_to_public_key(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z DelayedPaymentKey_write(const struct LDKDelayedPaymentKey *NONNULL_PTR obj);
+/* @internal */
+export function DelayedPaymentKey_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ DelayedPaymentKey_read(struct LDKu8slice ser);
+/* @internal */
+export function DelayedPaymentKey_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DelayedPaymentKey_read(ser);
+ return nativeResponseValue;
+}
+ // void HtlcBasepoint_free(struct LDKHtlcBasepoint this_obj);
+/* @internal */
+export function HtlcBasepoint_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_free(this_obj);
// debug statements here
}
- // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
+ // struct LDKPublicKey HtlcBasepoint_get_a(const struct LDKHtlcBasepoint *NONNULL_PTR this_ptr);
/* @internal */
-export function PhantomRouteHints_get_channels(this_ptr: bigint): number {
+export function HtlcBasepoint_get_a(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_get_a(this_ptr);
return nativeResponseValue;
}
- // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
+ // void HtlcBasepoint_set_a(struct LDKHtlcBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
/* @internal */
-export function PhantomRouteHints_set_channels(this_ptr: bigint, val: number): void {
+export function HtlcBasepoint_set_a(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_set_a(this_ptr, val);
// debug statements here
}
- // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKHtlcBasepoint HtlcBasepoint_new(struct LDKPublicKey a_arg);
/* @internal */
-export function PhantomRouteHints_get_phantom_scid(this_ptr: bigint): bigint {
+export function HtlcBasepoint_new(a_arg: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_new(a_arg);
return nativeResponseValue;
}
- // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
+ // bool HtlcBasepoint_eq(const struct LDKHtlcBasepoint *NONNULL_PTR a, const struct LDKHtlcBasepoint *NONNULL_PTR b);
/* @internal */
-export function PhantomRouteHints_set_phantom_scid(this_ptr: bigint, val: bigint): void {
+export function HtlcBasepoint_eq(a: bigint, b: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t HtlcBasepoint_clone_ptr(LDKHtlcBasepoint *NONNULL_PTR arg);
+/* @internal */
+export function HtlcBasepoint_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKHtlcBasepoint HtlcBasepoint_clone(const struct LDKHtlcBasepoint *NONNULL_PTR orig);
+/* @internal */
+export function HtlcBasepoint_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t HtlcBasepoint_hash(const struct LDKHtlcBasepoint *NONNULL_PTR o);
+/* @internal */
+export function HtlcBasepoint_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_hash(o);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey HtlcBasepoint_to_public_key(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg);
+/* @internal */
+export function HtlcBasepoint_to_public_key(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_to_public_key(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes HtlcBasepoint_derive_add_tweak(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg, struct LDKPublicKey per_commitment_point);
+/* @internal */
+export function HtlcBasepoint_derive_add_tweak(this_arg: bigint, per_commitment_point: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_derive_add_tweak(this_arg, per_commitment_point);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z HtlcBasepoint_write(const struct LDKHtlcBasepoint *NONNULL_PTR obj);
+/* @internal */
+export function HtlcBasepoint_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcBasepointDecodeErrorZ HtlcBasepoint_read(struct LDKu8slice ser);
+/* @internal */
+export function HtlcBasepoint_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcBasepoint_read(ser);
+ return nativeResponseValue;
+}
+ // void HtlcKey_free(struct LDKHtlcKey this_obj);
+/* @internal */
+export function HtlcKey_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HtlcKey_free(this_obj);
// debug statements here
}
- // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
+ // struct LDKPublicKey HtlcKey_get_a(const struct LDKHtlcKey *NONNULL_PTR this_ptr);
/* @internal */
-export function PhantomRouteHints_get_real_node_pubkey(this_ptr: bigint): number {
+export function HtlcKey_get_a(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
+ const nativeResponseValue = wasm.TS_HtlcKey_get_a(this_ptr);
return nativeResponseValue;
}
- // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void HtlcKey_set_a(struct LDKHtlcKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
/* @internal */
-export function PhantomRouteHints_set_real_node_pubkey(this_ptr: bigint, val: number): void {
+export function HtlcKey_set_a(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
+ const nativeResponseValue = wasm.TS_HtlcKey_set_a(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
+ // MUST_USE_RES struct LDKHtlcKey HtlcKey_new(struct LDKPublicKey a_arg);
/* @internal */
-export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): bigint {
+export function HtlcKey_new(a_arg: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
+ const nativeResponseValue = wasm.TS_HtlcKey_new(a_arg);
return nativeResponseValue;
}
- // uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
+ // bool HtlcKey_eq(const struct LDKHtlcKey *NONNULL_PTR a, const struct LDKHtlcKey *NONNULL_PTR b);
/* @internal */
-export function PhantomRouteHints_clone_ptr(arg: bigint): bigint {
+export function HtlcKey_eq(a: bigint, b: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_HtlcKey_eq(a, b);
return nativeResponseValue;
}
- // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
+ // uint64_t HtlcKey_clone_ptr(LDKHtlcKey *NONNULL_PTR arg);
/* @internal */
-export function PhantomRouteHints_clone(orig: bigint): bigint {
+export function HtlcKey_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
+ const nativeResponseValue = wasm.TS_HtlcKey_clone_ptr(arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKUserConfig config, struct LDKChainParameters params, uint32_t current_timestamp);
+ // struct LDKHtlcKey HtlcKey_clone(const struct LDKHtlcKey *NONNULL_PTR orig);
/* @internal */
-export function ChannelManager_new(fee_est: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, entropy_source: bigint, node_signer: bigint, signer_provider: bigint, config: bigint, params: bigint, current_timestamp: number): bigint {
+export function HtlcKey_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, router, logger, entropy_source, node_signer, signer_provider, config, params, current_timestamp);
+ const nativeResponseValue = wasm.TS_HtlcKey_clone(orig);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_basepoint(const struct LDKHtlcBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
/* @internal */
-export function ChannelManager_get_current_default_configuration(this_arg: bigint): bigint {
+export function HtlcKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
+ const nativeResponseValue = wasm.TS_HtlcKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_ChannelIdAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, struct LDKU128 user_channel_id, struct LDKChannelId temporary_channel_id, struct LDKUserConfig override_config);
+ // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_secret_key(const uint8_t (*sk)[32]);
/* @internal */
-export function ChannelManager_create_channel(this_arg: bigint, their_network_key: number, channel_value_satoshis: bigint, push_msat: bigint, user_channel_id: number, temporary_channel_id: bigint, override_config: bigint): bigint {
+export function HtlcKey_from_secret_key(sk: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, temporary_channel_id, override_config);
+ const nativeResponseValue = wasm.TS_HtlcKey_from_secret_key(sk);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // MUST_USE_RES struct LDKPublicKey HtlcKey_to_public_key(const struct LDKHtlcKey *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelManager_list_channels(this_arg: bigint): number {
+export function HtlcKey_to_public_key(this_arg: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
+ const nativeResponseValue = wasm.TS_HtlcKey_to_public_key(this_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCVec_u8Z HtlcKey_write(const struct LDKHtlcKey *NONNULL_PTR obj);
/* @internal */
-export function ChannelManager_list_usable_channels(this_arg: bigint): number {
+export function HtlcKey_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
+ const nativeResponseValue = wasm.TS_HtlcKey_write(obj);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels_with_counterparty(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id);
+ // struct LDKCResult_HtlcKeyDecodeErrorZ HtlcKey_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelManager_list_channels_with_counterparty(this_arg: bigint, counterparty_node_id: number): number {
+export function HtlcKey_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_list_channels_with_counterparty(this_arg, counterparty_node_id);
+ const nativeResponseValue = wasm.TS_HtlcKey_read(ser);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCVec_RecentPaymentDetailsZ ChannelManager_list_recent_payments(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKPublicKey add_public_key_tweak(struct LDKPublicKey base_point, const uint8_t (*tweak)[32]);
/* @internal */
-export function ChannelManager_list_recent_payments(this_arg: bigint): number {
+export function add_public_key_tweak(base_point: number, tweak: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_list_recent_payments(this_arg);
+ const nativeResponseValue = wasm.TS_add_public_key_tweak(base_point, tweak);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
+ // void RevocationBasepoint_free(struct LDKRevocationBasepoint this_obj);
/* @internal */
-export function ChannelManager_close_channel(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
+export function RevocationBasepoint_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_free(this_obj);
+ // debug statements here
+}
+ // struct LDKPublicKey RevocationBasepoint_get_a(const struct LDKRevocationBasepoint *NONNULL_PTR this_ptr);
+/* @internal */
+export function RevocationBasepoint_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void RevocationBasepoint_set_a(struct LDKRevocationBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function RevocationBasepoint_set_a(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKRevocationBasepoint RevocationBasepoint_new(struct LDKPublicKey a_arg);
+/* @internal */
+export function RevocationBasepoint_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_new(a_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_close_channel_with_feerate_and_script(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id, struct LDKCOption_u32Z target_feerate_sats_per_1000_weight, struct LDKShutdownScript shutdown_script);
+ // bool RevocationBasepoint_eq(const struct LDKRevocationBasepoint *NONNULL_PTR a, const struct LDKRevocationBasepoint *NONNULL_PTR b);
+/* @internal */
+export function RevocationBasepoint_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t RevocationBasepoint_clone_ptr(LDKRevocationBasepoint *NONNULL_PTR arg);
+/* @internal */
+export function RevocationBasepoint_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKRevocationBasepoint RevocationBasepoint_clone(const struct LDKRevocationBasepoint *NONNULL_PTR orig);
+/* @internal */
+export function RevocationBasepoint_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t RevocationBasepoint_hash(const struct LDKRevocationBasepoint *NONNULL_PTR o);
+/* @internal */
+export function RevocationBasepoint_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_hash(o);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey RevocationBasepoint_to_public_key(const struct LDKRevocationBasepoint *NONNULL_PTR this_arg);
+/* @internal */
+export function RevocationBasepoint_to_public_key(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_to_public_key(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z RevocationBasepoint_write(const struct LDKRevocationBasepoint *NONNULL_PTR obj);
+/* @internal */
+export function RevocationBasepoint_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationBasepointDecodeErrorZ RevocationBasepoint_read(struct LDKu8slice ser);
+/* @internal */
+export function RevocationBasepoint_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationBasepoint_read(ser);
+ return nativeResponseValue;
+}
+ // void RevocationKey_free(struct LDKRevocationKey this_obj);
+/* @internal */
+export function RevocationKey_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationKey_free(this_obj);
+ // debug statements here
+}
+ // struct LDKPublicKey RevocationKey_get_a(const struct LDKRevocationKey *NONNULL_PTR this_ptr);
+/* @internal */
+export function RevocationKey_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationKey_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void RevocationKey_set_a(struct LDKRevocationKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function RevocationKey_set_a(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RevocationKey_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKRevocationKey RevocationKey_new(struct LDKPublicKey a_arg);
/* @internal */
-export function ChannelManager_close_channel_with_feerate_and_script(this_arg: bigint, channel_id: bigint, counterparty_node_id: number, target_feerate_sats_per_1000_weight: bigint, shutdown_script: bigint): bigint {
+export function RevocationKey_new(a_arg: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_feerate_and_script(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight, shutdown_script);
+ const nativeResponseValue = wasm.TS_RevocationKey_new(a_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
+ // bool RevocationKey_eq(const struct LDKRevocationKey *NONNULL_PTR a, const struct LDKRevocationKey *NONNULL_PTR b);
/* @internal */
-export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
+export function RevocationKey_eq(a: bigint, b: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
+ const nativeResponseValue = wasm.TS_RevocationKey_eq(a, b);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR channel_id, struct LDKPublicKey counterparty_node_id);
+ // uint64_t RevocationKey_clone_ptr(LDKRevocationKey *NONNULL_PTR arg);
/* @internal */
-export function ChannelManager_force_close_without_broadcasting_txn(this_arg: bigint, channel_id: bigint, counterparty_node_id: number): bigint {
+export function RevocationKey_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
+ const nativeResponseValue = wasm.TS_RevocationKey_clone_ptr(arg);
return nativeResponseValue;
}
- // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKRevocationKey RevocationKey_clone(const struct LDKRevocationKey *NONNULL_PTR orig);
/* @internal */
-export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: bigint): void {
+export function RevocationKey_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
- // debug statements here
+ const nativeResponseValue = wasm.TS_RevocationKey_clone(orig);
+ return nativeResponseValue;
}
- // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // uint64_t RevocationKey_hash(const struct LDKRevocationKey *NONNULL_PTR o);
/* @internal */
-export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: bigint): void {
+export function RevocationKey_hash(o: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
- // debug statements here
+ const nativeResponseValue = wasm.TS_RevocationKey_hash(o);
+ return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NonePaymentSendFailureZ ChannelManager_send_payment_with_route(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
+ // MUST_USE_RES struct LDKRevocationKey RevocationKey_from_basepoint(const struct LDKRevocationBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
/* @internal */
-export function ChannelManager_send_payment_with_route(this_arg: bigint, route: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number): bigint {
+export function RevocationKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_payment_with_route(this_arg, route, payment_hash, recipient_onion, payment_id);
+ const nativeResponseValue = wasm.TS_RevocationKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneRetryableSendFailureZ ChannelManager_send_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
+ // MUST_USE_RES struct LDKPublicKey RevocationKey_to_public_key(const struct LDKRevocationKey *NONNULL_PTR this_arg);
/* @internal */
-export function ChannelManager_send_payment(this_arg: bigint, payment_hash: number, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
+export function RevocationKey_to_public_key(this_arg: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, payment_hash, recipient_onion, payment_id, route_params, retry_strategy);
+ const nativeResponseValue = wasm.TS_RevocationKey_to_public_key(this_arg);
return nativeResponseValue;
}
- // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
+ // struct LDKCVec_u8Z RevocationKey_write(const struct LDKRevocationKey *NONNULL_PTR obj);
/* @internal */
-export function ChannelManager_abandon_payment(this_arg: bigint, payment_id: number): void {
+export function RevocationKey_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
- // debug statements here
+ const nativeResponseValue = wasm.TS_RevocationKey_write(obj);
+ return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesPaymentSendFailureZ ChannelManager_send_spontaneous_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id);
+ // struct LDKCResult_RevocationKeyDecodeErrorZ RevocationKey_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelManager_send_spontaneous_payment(this_arg: bigint, route: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number): bigint {
+export function RevocationKey_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage, recipient_onion, payment_id);
+ const nativeResponseValue = wasm.TS_RevocationKey_read(ser);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesRetryableSendFailureZ ChannelManager_send_spontaneous_payment_with_retry(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_ThirtyTwoBytesZ payment_preimage, struct LDKRecipientOnionFields recipient_onion, struct LDKThirtyTwoBytes payment_id, struct LDKRouteParameters route_params, struct LDKRetry retry_strategy);
+ // enum LDKInboundHTLCStateDetails InboundHTLCStateDetails_clone(const enum LDKInboundHTLCStateDetails *NONNULL_PTR orig);
/* @internal */
-export function ChannelManager_send_spontaneous_payment_with_retry(this_arg: bigint, payment_preimage: bigint, recipient_onion: bigint, payment_id: number, route_params: bigint, retry_strategy: bigint): bigint {
+export function InboundHTLCStateDetails_clone(orig: bigint): InboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment_with_retry(this_arg, payment_preimage, recipient_onion, payment_id, route_params, retry_strategy);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_clone(orig);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPath path);
+ // enum LDKInboundHTLCStateDetails InboundHTLCStateDetails_awaiting_remote_revoke_to_add(void);
/* @internal */
-export function ChannelManager_send_probe(this_arg: bigint, path: bigint): bigint {
+export function InboundHTLCStateDetails_awaiting_remote_revoke_to_add(): InboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, path);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_awaiting_remote_revoke_to_add();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_spontaneous_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, uint64_t amount_msat, uint32_t final_cltv_expiry_delta, struct LDKCOption_u64Z liquidity_limit_multiplier);
+ // enum LDKInboundHTLCStateDetails InboundHTLCStateDetails_committed(void);
/* @internal */
-export function ChannelManager_send_spontaneous_preflight_probes(this_arg: bigint, node_id: number, amount_msat: bigint, final_cltv_expiry_delta: number, liquidity_limit_multiplier: bigint): bigint {
+export function InboundHTLCStateDetails_committed(): InboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_preflight_probes(this_arg, node_id, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_committed();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ ChannelManager_send_preflight_probes(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKRouteParameters route_params, struct LDKCOption_u64Z liquidity_limit_multiplier);
+ // enum LDKInboundHTLCStateDetails InboundHTLCStateDetails_awaiting_remote_revoke_to_remove_fulfill(void);
/* @internal */
-export function ChannelManager_send_preflight_probes(this_arg: bigint, route_params: bigint, liquidity_limit_multiplier: bigint): bigint {
+export function InboundHTLCStateDetails_awaiting_remote_revoke_to_remove_fulfill(): InboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_send_preflight_probes(this_arg, route_params, liquidity_limit_multiplier);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_awaiting_remote_revoke_to_remove_fulfill();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKTransaction funding_transaction);
+ // enum LDKInboundHTLCStateDetails InboundHTLCStateDetails_awaiting_remote_revoke_to_remove_fail(void);
/* @internal */
-export function ChannelManager_funding_transaction_generated(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, funding_transaction: number): bigint {
+export function InboundHTLCStateDetails_awaiting_remote_revoke_to_remove_fail(): InboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_awaiting_remote_revoke_to_remove_fail();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_batch_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_C2Tuple_ChannelIdPublicKeyZZ temporary_channels, struct LDKTransaction funding_transaction);
+ // struct LDKCVec_u8Z InboundHTLCStateDetails_write(const enum LDKInboundHTLCStateDetails *NONNULL_PTR obj);
/* @internal */
-export function ChannelManager_batch_funding_transaction_generated(this_arg: bigint, temporary_channels: number, funding_transaction: number): bigint {
+export function InboundHTLCStateDetails_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_batch_funding_transaction_generated(this_arg, temporary_channels, funding_transaction);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_write(obj);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_partial_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ChannelIdZ channel_ids, const struct LDKChannelConfigUpdate *NONNULL_PTR config_update);
+ // struct LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ InboundHTLCStateDetails_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelManager_update_partial_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config_update: bigint): bigint {
+export function InboundHTLCStateDetails_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_update_partial_channel_config(this_arg, counterparty_node_id, channel_ids, config_update);
+ const nativeResponseValue = wasm.TS_InboundHTLCStateDetails_read(ser);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ChannelIdZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
+ // void InboundHTLCDetails_free(struct LDKInboundHTLCDetails this_obj);
/* @internal */
-export function ChannelManager_update_channel_config(this_arg: bigint, counterparty_node_id: number, channel_ids: number, config: bigint): bigint {
+export function InboundHTLCDetails_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_free(this_obj);
+ // debug statements here
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_forward_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id, const struct LDKChannelId *NONNULL_PTR next_hop_channel_id, struct LDKPublicKey next_node_id, uint64_t amt_to_forward_msat);
+ // uint64_t InboundHTLCDetails_get_htlc_id(const struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_forward_intercepted_htlc(this_arg: bigint, intercept_id: number, next_hop_channel_id: bigint, next_node_id: number, amt_to_forward_msat: bigint): bigint {
+export function InboundHTLCDetails_get_htlc_id(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_forward_intercepted_htlc(this_arg, intercept_id, next_hop_channel_id, next_node_id, amt_to_forward_msat);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_get_htlc_id(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_fail_intercepted_htlc(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes intercept_id);
+ // void InboundHTLCDetails_set_htlc_id(struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function ChannelManager_fail_intercepted_htlc(this_arg: bigint, intercept_id: number): bigint {
+export function InboundHTLCDetails_set_htlc_id(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_fail_intercepted_htlc(this_arg, intercept_id);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_set_htlc_id(this_ptr, val);
+ // debug statements here
}
- // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // uint64_t InboundHTLCDetails_get_amount_msat(const struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_process_pending_htlc_forwards(this_arg: bigint): void {
+export function InboundHTLCDetails_get_amount_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
- // debug statements here
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_get_amount_msat(this_ptr);
+ return nativeResponseValue;
}
- // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void InboundHTLCDetails_set_amount_msat(struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function ChannelManager_timer_tick_occurred(this_arg: bigint): void {
+export function InboundHTLCDetails_set_amount_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_set_amount_msat(this_ptr, val);
// debug statements here
}
- // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
+ // uint32_t InboundHTLCDetails_get_cltv_expiry(const struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_fail_htlc_backwards(this_arg: bigint, payment_hash: number): void {
+export function InboundHTLCDetails_get_cltv_expiry(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
- // debug statements here
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_get_cltv_expiry(this_ptr);
+ return nativeResponseValue;
}
- // void ChannelManager_fail_htlc_backwards_with_reason(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKFailureCode failure_code);
+ // void InboundHTLCDetails_set_cltv_expiry(struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr, uint32_t val);
/* @internal */
-export function ChannelManager_fail_htlc_backwards_with_reason(this_arg: bigint, payment_hash: number, failure_code: bigint): void {
+export function InboundHTLCDetails_set_cltv_expiry(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards_with_reason(this_arg, payment_hash, failure_code);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_set_cltv_expiry(this_ptr, val);
// debug statements here
}
- // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
+ // const uint8_t (*InboundHTLCDetails_get_payment_hash(const struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr))[32];
/* @internal */
-export function ChannelManager_claim_funds(this_arg: bigint, payment_preimage: number): void {
+export function InboundHTLCDetails_get_payment_hash(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
- // debug statements here
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_get_payment_hash(this_ptr);
+ return nativeResponseValue;
}
- // void ChannelManager_claim_funds_with_known_custom_tlvs(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
+ // void InboundHTLCDetails_set_payment_hash(struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
/* @internal */
-export function ChannelManager_claim_funds_with_known_custom_tlvs(this_arg: bigint, payment_preimage: number): void {
+export function InboundHTLCDetails_set_payment_hash(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_claim_funds_with_known_custom_tlvs(this_arg, payment_preimage);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_set_payment_hash(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCOption_InboundHTLCStateDetailsZ InboundHTLCDetails_get_state(const struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_get_our_node_id(this_arg: bigint): number {
+export function InboundHTLCDetails_get_state(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_get_state(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
+ // void InboundHTLCDetails_set_state(struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr, struct LDKCOption_InboundHTLCStateDetailsZ val);
/* @internal */
-export function ChannelManager_accept_inbound_channel(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, user_channel_id: number): bigint {
+export function InboundHTLCDetails_set_state(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_set_state(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKChannelId *NONNULL_PTR temporary_channel_id, struct LDKPublicKey counterparty_node_id, struct LDKU128 user_channel_id);
+ // bool InboundHTLCDetails_get_is_dust(const struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg: bigint, temporary_channel_id: bigint, counterparty_node_id: number, user_channel_id: number): bigint {
+export function InboundHTLCDetails_get_is_dust(this_ptr: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_get_is_dust(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ ChannelManager_create_offer_builder(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void InboundHTLCDetails_set_is_dust(struct LDKInboundHTLCDetails *NONNULL_PTR this_ptr, bool val);
/* @internal */
-export function ChannelManager_create_offer_builder(this_arg: bigint): bigint {
+export function InboundHTLCDetails_set_is_dust(this_ptr: bigint, val: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_create_offer_builder(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_set_is_dust(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ ChannelManager_create_refund_builder(const struct LDKChannelManager *NONNULL_PTR this_arg, uint64_t amount_msats, uint64_t absolute_expiry, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, struct LDKCOption_u64Z max_total_routing_fee_msat);
+ // MUST_USE_RES struct LDKInboundHTLCDetails InboundHTLCDetails_new(uint64_t htlc_id_arg, uint64_t amount_msat_arg, uint32_t cltv_expiry_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_InboundHTLCStateDetailsZ state_arg, bool is_dust_arg);
/* @internal */
-export function ChannelManager_create_refund_builder(this_arg: bigint, amount_msats: bigint, absolute_expiry: bigint, payment_id: number, retry_strategy: bigint, max_total_routing_fee_msat: bigint): bigint {
+export function InboundHTLCDetails_new(htlc_id_arg: bigint, amount_msat_arg: bigint, cltv_expiry_arg: number, payment_hash_arg: number, state_arg: bigint, is_dust_arg: boolean): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_create_refund_builder(this_arg, amount_msats, absolute_expiry, payment_id, retry_strategy, max_total_routing_fee_msat);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_new(htlc_id_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, state_arg, is_dust_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_NoneBolt12SemanticErrorZ ChannelManager_pay_for_offer(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKOffer *NONNULL_PTR offer, struct LDKCOption_u64Z quantity, struct LDKCOption_u64Z amount_msats, struct LDKCOption_StrZ payer_note, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, struct LDKCOption_u64Z max_total_routing_fee_msat);
+ // uint64_t InboundHTLCDetails_clone_ptr(LDKInboundHTLCDetails *NONNULL_PTR arg);
/* @internal */
-export function ChannelManager_pay_for_offer(this_arg: bigint, offer: bigint, quantity: bigint, amount_msats: bigint, payer_note: bigint, payment_id: number, retry_strategy: bigint, max_total_routing_fee_msat: bigint): bigint {
+export function InboundHTLCDetails_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_pay_for_offer(this_arg, offer, quantity, amount_msats, payer_note, payment_id, retry_strategy, max_total_routing_fee_msat);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_clone_ptr(arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ ChannelManager_request_refund_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, const struct LDKRefund *NONNULL_PTR refund);
+ // struct LDKInboundHTLCDetails InboundHTLCDetails_clone(const struct LDKInboundHTLCDetails *NONNULL_PTR orig);
/* @internal */
-export function ChannelManager_request_refund_payment(this_arg: bigint, refund: bigint): bigint {
+export function InboundHTLCDetails_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_request_refund_payment(this_arg, refund);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_clone(orig);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ ChannelManager_create_inbound_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
+ // struct LDKCVec_u8Z InboundHTLCDetails_write(const struct LDKInboundHTLCDetails *NONNULL_PTR obj);
/* @internal */
-export function ChannelManager_create_inbound_payment(this_arg: bigint, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
+export function InboundHTLCDetails_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_write(obj);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesNoneZ ChannelManager_create_inbound_payment_for_hash(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z min_value_msat, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry);
+ // struct LDKCResult_InboundHTLCDetailsDecodeErrorZ InboundHTLCDetails_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelManager_create_inbound_payment_for_hash(this_arg: bigint, payment_hash: number, min_value_msat: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry: bigint): bigint {
+export function InboundHTLCDetails_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs, min_final_cltv_expiry);
+ const nativeResponseValue = wasm.TS_InboundHTLCDetails_read(ser);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKCResult_ThirtyTwoBytesAPIErrorZ ChannelManager_get_payment_preimage(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
+ // enum LDKOutboundHTLCStateDetails OutboundHTLCStateDetails_clone(const enum LDKOutboundHTLCStateDetails *NONNULL_PTR orig);
/* @internal */
-export function ChannelManager_get_payment_preimage(this_arg: bigint, payment_hash: number, payment_secret: number): bigint {
+export function OutboundHTLCStateDetails_clone(orig: bigint): OutboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_clone(orig);
return nativeResponseValue;
}
- // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // enum LDKOutboundHTLCStateDetails OutboundHTLCStateDetails_awaiting_remote_revoke_to_add(void);
/* @internal */
-export function ChannelManager_get_phantom_scid(this_arg: bigint): bigint {
+export function OutboundHTLCStateDetails_awaiting_remote_revoke_to_add(): OutboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_awaiting_remote_revoke_to_add();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // enum LDKOutboundHTLCStateDetails OutboundHTLCStateDetails_committed(void);
/* @internal */
-export function ChannelManager_get_phantom_route_hints(this_arg: bigint): bigint {
+export function OutboundHTLCStateDetails_committed(): OutboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_committed();
return nativeResponseValue;
}
- // MUST_USE_RES uint64_t ChannelManager_get_intercept_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // enum LDKOutboundHTLCStateDetails OutboundHTLCStateDetails_awaiting_remote_revoke_to_remove_success(void);
/* @internal */
-export function ChannelManager_get_intercept_scid(this_arg: bigint): bigint {
+export function OutboundHTLCStateDetails_awaiting_remote_revoke_to_remove_success(): OutboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_intercept_scid(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_awaiting_remote_revoke_to_remove_success();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKInFlightHtlcs ChannelManager_compute_inflight_htlcs(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // enum LDKOutboundHTLCStateDetails OutboundHTLCStateDetails_awaiting_remote_revoke_to_remove_failure(void);
/* @internal */
-export function ChannelManager_compute_inflight_htlcs(this_arg: bigint): bigint {
+export function OutboundHTLCStateDetails_awaiting_remote_revoke_to_remove_failure(): OutboundHTLCStateDetails {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_compute_inflight_htlcs(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_awaiting_remote_revoke_to_remove_failure();
return nativeResponseValue;
}
- // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCVec_u8Z OutboundHTLCStateDetails_write(const enum LDKOutboundHTLCStateDetails *NONNULL_PTR obj);
/* @internal */
-export function ChannelManager_as_MessageSendEventsProvider(this_arg: bigint): bigint {
+export function OutboundHTLCStateDetails_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_write(obj);
return nativeResponseValue;
}
- // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ OutboundHTLCStateDetails_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelManager_as_EventsProvider(this_arg: bigint): bigint {
+export function OutboundHTLCStateDetails_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCStateDetails_read(ser);
return nativeResponseValue;
}
- // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void OutboundHTLCDetails_free(struct LDKOutboundHTLCDetails this_obj);
/* @internal */
-export function ChannelManager_as_Listen(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_free(this_obj);
+ // debug statements here
}
- // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCOption_u64Z OutboundHTLCDetails_get_htlc_id(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_as_Confirm(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_get_htlc_id(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_htlc_id(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKFuture ChannelManager_get_event_or_persistence_needed_future(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void OutboundHTLCDetails_set_htlc_id(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function ChannelManager_get_event_or_persistence_needed_future(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_set_htlc_id(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_event_or_persistence_needed_future(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_htlc_id(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES bool ChannelManager_get_and_clear_needs_persistence(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // uint64_t OutboundHTLCDetails_get_amount_msat(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_get_and_clear_needs_persistence(this_arg: bigint): boolean {
+export function OutboundHTLCDetails_get_amount_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_get_and_clear_needs_persistence(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_amount_msat(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void OutboundHTLCDetails_set_amount_msat(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function ChannelManager_current_best_block(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_set_amount_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_amount_msat(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKNodeFeatures ChannelManager_node_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // uint32_t OutboundHTLCDetails_get_cltv_expiry(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_node_features(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_get_cltv_expiry(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_node_features(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_cltv_expiry(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKChannelFeatures ChannelManager_channel_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void OutboundHTLCDetails_set_cltv_expiry(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, uint32_t val);
/* @internal */
-export function ChannelManager_channel_features(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_set_cltv_expiry(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_channel_features(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_cltv_expiry(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKChannelTypeFeatures ChannelManager_channel_type_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // const uint8_t (*OutboundHTLCDetails_get_payment_hash(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr))[32];
/* @internal */
-export function ChannelManager_channel_type_features(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_get_payment_hash(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_channel_type_features(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_payment_hash(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKInitFeatures ChannelManager_init_features(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void OutboundHTLCDetails_set_payment_hash(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
/* @internal */
-export function ChannelManager_init_features(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_set_payment_hash(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_init_features(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_payment_hash(this_ptr, val);
+ // debug statements here
}
- // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCOption_OutboundHTLCStateDetailsZ OutboundHTLCDetails_get_state(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_as_ChannelMessageHandler(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_get_state(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_state(this_ptr);
return nativeResponseValue;
}
- // struct LDKOffersMessageHandler ChannelManager_as_OffersMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // void OutboundHTLCDetails_set_state(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, struct LDKCOption_OutboundHTLCStateDetailsZ val);
/* @internal */
-export function ChannelManager_as_OffersMessageHandler(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_set_state(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_OffersMessageHandler(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_state(this_ptr, val);
+ // debug statements here
}
- // struct LDKNodeIdLookUp ChannelManager_as_NodeIdLookUp(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ // struct LDKCOption_u64Z OutboundHTLCDetails_get_skimmed_fee_msat(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManager_as_NodeIdLookUp(this_arg: bigint): bigint {
+export function OutboundHTLCDetails_get_skimmed_fee_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_as_NodeIdLookUp(this_arg);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_skimmed_fee_msat(this_ptr);
return nativeResponseValue;
}
- // struct LDKInitFeatures provided_init_features(const struct LDKUserConfig *NONNULL_PTR config);
+ // void OutboundHTLCDetails_set_skimmed_fee_msat(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function provided_init_features(config: bigint): bigint {
+export function OutboundHTLCDetails_set_skimmed_fee_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_provided_init_features(config);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_skimmed_fee_msat(this_ptr, val);
+ // debug statements here
}
- // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
+ // bool OutboundHTLCDetails_get_is_dust(const struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function CounterpartyForwardingInfo_write(obj: bigint): number {
+export function OutboundHTLCDetails_get_is_dust(this_ptr: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_get_is_dust(this_ptr);
return nativeResponseValue;
}
- // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
+ // void OutboundHTLCDetails_set_is_dust(struct LDKOutboundHTLCDetails *NONNULL_PTR this_ptr, bool val);
/* @internal */
-export function CounterpartyForwardingInfo_read(ser: number): bigint {
+export function OutboundHTLCDetails_set_is_dust(this_ptr: bigint, val: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_set_is_dust(this_ptr, val);
+ // debug statements here
}
- // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
+ // MUST_USE_RES struct LDKOutboundHTLCDetails OutboundHTLCDetails_new(struct LDKCOption_u64Z htlc_id_arg, uint64_t amount_msat_arg, uint32_t cltv_expiry_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_OutboundHTLCStateDetailsZ state_arg, struct LDKCOption_u64Z skimmed_fee_msat_arg, bool is_dust_arg);
/* @internal */
-export function ChannelCounterparty_write(obj: bigint): number {
+export function OutboundHTLCDetails_new(htlc_id_arg: bigint, amount_msat_arg: bigint, cltv_expiry_arg: number, payment_hash_arg: number, state_arg: bigint, skimmed_fee_msat_arg: bigint, is_dust_arg: boolean): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_new(htlc_id_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, state_arg, skimmed_fee_msat_arg, is_dust_arg);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
+ // uint64_t OutboundHTLCDetails_clone_ptr(LDKOutboundHTLCDetails *NONNULL_PTR arg);
/* @internal */
-export function ChannelCounterparty_read(ser: number): bigint {
+export function OutboundHTLCDetails_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_clone_ptr(arg);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
+ // struct LDKOutboundHTLCDetails OutboundHTLCDetails_clone(const struct LDKOutboundHTLCDetails *NONNULL_PTR orig);
/* @internal */
-export function ChannelDetails_write(obj: bigint): number {
+export function OutboundHTLCDetails_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
+ // struct LDKCVec_u8Z OutboundHTLCDetails_write(const struct LDKOutboundHTLCDetails *NONNULL_PTR obj);
/* @internal */
-export function ChannelDetails_read(ser: number): bigint {
+export function OutboundHTLCDetails_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_write(obj);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
+ // struct LDKCResult_OutboundHTLCDetailsDecodeErrorZ OutboundHTLCDetails_read(struct LDKu8slice ser);
/* @internal */
-export function PhantomRouteHints_write(obj: bigint): number {
+export function OutboundHTLCDetails_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
+ const nativeResponseValue = wasm.TS_OutboundHTLCDetails_read(ser);
return nativeResponseValue;
}
- // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
+ // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
/* @internal */
-export function PhantomRouteHints_read(ser: number): bigint {
+export function CounterpartyForwardingInfo_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
+ // debug statements here
}
- // struct LDKCVec_u8Z BlindedForward_write(const struct LDKBlindedForward *NONNULL_PTR obj);
+ // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
/* @internal */
-export function BlindedForward_write(obj: bigint): number {
+export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_BlindedForward_write(obj);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
return nativeResponseValue;
}
- // struct LDKCResult_BlindedForwardDecodeErrorZ BlindedForward_read(struct LDKu8slice ser);
+ // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
/* @internal */
-export function BlindedForward_read(ser: number): bigint {
+export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_BlindedForward_read(ser);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
+ // debug statements here
}
- // struct LDKCVec_u8Z PendingHTLCRouting_write(const struct LDKPendingHTLCRouting *NONNULL_PTR obj);
+ // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
/* @internal */
-export function PendingHTLCRouting_write(obj: bigint): number {
+export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PendingHTLCRouting_write(obj);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
return nativeResponseValue;
}
- // struct LDKCResult_PendingHTLCRoutingDecodeErrorZ PendingHTLCRouting_read(struct LDKu8slice ser);
+ // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
/* @internal */
-export function PendingHTLCRouting_read(ser: number): bigint {
+export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PendingHTLCRouting_read(ser);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
+ // debug statements here
}
- // struct LDKCVec_u8Z PendingHTLCInfo_write(const struct LDKPendingHTLCInfo *NONNULL_PTR obj);
+ // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
/* @internal */
-export function PendingHTLCInfo_write(obj: bigint): number {
+export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PendingHTLCInfo_write(obj);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
return nativeResponseValue;
}
- // struct LDKCResult_PendingHTLCInfoDecodeErrorZ PendingHTLCInfo_read(struct LDKu8slice ser);
+ // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
/* @internal */
-export function PendingHTLCInfo_read(ser: number): bigint {
+export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_PendingHTLCInfo_read(ser);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
+ // debug statements here
}
- // struct LDKCVec_u8Z BlindedFailure_write(const enum LDKBlindedFailure *NONNULL_PTR obj);
+ // MUST_USE_RES struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_new(uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg);
/* @internal */
-export function BlindedFailure_write(obj: bigint): number {
+export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_BlindedFailure_write(obj);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
return nativeResponseValue;
}
- // struct LDKCResult_BlindedFailureDecodeErrorZ BlindedFailure_read(struct LDKu8slice ser);
+ // uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
/* @internal */
-export function BlindedFailure_read(ser: number): bigint {
+export function CounterpartyForwardingInfo_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_BlindedFailure_read(ser);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
+ // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
/* @internal */
-export function ChannelManager_write(obj: bigint): number {
+export function CounterpartyForwardingInfo_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
+ // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
/* @internal */
-export function ChannelShutdownState_write(obj: bigint): number {
+export function CounterpartyForwardingInfo_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
+ // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelShutdownState_read(ser: number): bigint {
+export function CounterpartyForwardingInfo_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
+ const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
+ // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
/* @internal */
-export function ChannelManagerReadArgs_free(this_obj: bigint): void {
+export function ChannelCounterparty_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
// debug statements here
}
- // const struct LDKEntropySource *ChannelManagerReadArgs_get_entropy_source(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManagerReadArgs_get_entropy_source(this_ptr: bigint): bigint {
+export function ChannelCounterparty_get_node_id(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_entropy_source(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_entropy_source(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKEntropySource val);
+ // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
/* @internal */
-export function ChannelManagerReadArgs_set_entropy_source(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_set_node_id(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_entropy_source(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
// debug statements here
}
- // const struct LDKNodeSigner *ChannelManagerReadArgs_get_node_signer(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManagerReadArgs_get_node_signer(this_ptr: bigint): bigint {
+export function ChannelCounterparty_get_features(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_node_signer(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_node_signer(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKNodeSigner val);
+ // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
/* @internal */
-export function ChannelManagerReadArgs_set_node_signer(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_set_features(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_node_signer(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
// debug statements here
}
- // const struct LDKSignerProvider *ChannelManagerReadArgs_get_signer_provider(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManagerReadArgs_get_signer_provider(this_ptr: bigint): bigint {
+export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_signer_provider(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_signer_provider(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKSignerProvider val);
+ // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function ChannelManagerReadArgs_set_signer_provider(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_signer_provider(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
// debug statements here
}
- // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: bigint): bigint {
+export function ChannelCounterparty_get_forwarding_info(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
+ // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
/* @internal */
-export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_set_forwarding_info(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
// debug statements here
}
- // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: bigint): bigint {
+export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
+ // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
// debug statements here
}
- // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
/* @internal */
-export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: bigint): bigint {
+export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
+ // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
// debug statements here
}
- // const struct LDKRouter *ChannelManagerReadArgs_get_router(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // MUST_USE_RES struct LDKChannelCounterparty ChannelCounterparty_new(struct LDKPublicKey node_id_arg, struct LDKInitFeatures features_arg, uint64_t unspendable_punishment_reserve_arg, struct LDKCounterpartyForwardingInfo forwarding_info_arg, struct LDKCOption_u64Z outbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z outbound_htlc_maximum_msat_arg);
/* @internal */
-export function ChannelManagerReadArgs_get_router(this_ptr: bigint): bigint {
+export function ChannelCounterparty_new(node_id_arg: number, features_arg: bigint, unspendable_punishment_reserve_arg: bigint, forwarding_info_arg: bigint, outbound_htlc_minimum_msat_arg: bigint, outbound_htlc_maximum_msat_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_router(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_new(node_id_arg, features_arg, unspendable_punishment_reserve_arg, forwarding_info_arg, outbound_htlc_minimum_msat_arg, outbound_htlc_maximum_msat_arg);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_router(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKRouter val);
+ // uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
/* @internal */
-export function ChannelManagerReadArgs_set_router(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_router(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
+ return nativeResponseValue;
}
- // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
/* @internal */
-export function ChannelManagerReadArgs_get_logger(this_ptr: bigint): bigint {
+export function ChannelCounterparty_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
+ // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
/* @internal */
-export function ChannelManagerReadArgs_set_logger(this_ptr: bigint, val: bigint): void {
+export function ChannelCounterparty_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
+ return nativeResponseValue;
}
- // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
+ // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
/* @internal */
-export function ChannelManagerReadArgs_get_default_config(this_ptr: bigint): bigint {
+export function ChannelCounterparty_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
return nativeResponseValue;
}
- // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
+ // void ChannelDetails_free(struct LDKChannelDetails this_obj);
/* @internal */
-export function ChannelManagerReadArgs_set_default_config(this_ptr: bigint, val: bigint): void {
+export function ChannelDetails_free(this_obj: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
// debug statements here
}
- // MUST_USE_RES struct LDKChannelManagerReadArgs ChannelManagerReadArgs_new(struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKSignerProvider signer_provider, struct LDKFeeEstimator fee_estimator, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKRouter router, struct LDKLogger logger, struct LDKUserConfig default_config, struct LDKCVec_ChannelMonitorZ channel_monitors);
-/* @internal */
-export function ChannelManagerReadArgs_new(entropy_source: bigint, node_signer: bigint, signer_provider: bigint, fee_estimator: bigint, chain_monitor: bigint, tx_broadcaster: bigint, router: bigint, logger: bigint, default_config: bigint, channel_monitors: number): bigint {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(entropy_source, node_signer, signer_provider, fee_estimator, chain_monitor, tx_broadcaster, router, logger, default_config, channel_monitors);
- return nativeResponseValue;
-}
- // struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ C2Tuple_ThirtyTwoBytesChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
+ // struct LDKChannelId ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser: number, arg: bigint): bigint {
+export function ChannelDetails_get_channel_id(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser, arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
return nativeResponseValue;
}
- // void DelayedPaymentBasepoint_free(struct LDKDelayedPaymentBasepoint this_obj);
+ // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelId val);
/* @internal */
-export function DelayedPaymentBasepoint_free(this_obj: bigint): void {
+export function ChannelDetails_set_channel_id(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_free(this_obj);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey DelayedPaymentBasepoint_get_a(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr);
+ // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentBasepoint_get_a(this_ptr: bigint): number {
+export function ChannelDetails_get_counterparty(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_get_a(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
return nativeResponseValue;
}
- // void DelayedPaymentBasepoint_set_a(struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
/* @internal */
-export function DelayedPaymentBasepoint_set_a(this_ptr: bigint, val: number): void {
+export function ChannelDetails_set_counterparty(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_set_a(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_new(struct LDKPublicKey a_arg);
+ // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentBasepoint_new(a_arg: number): bigint {
+export function ChannelDetails_get_funding_txo(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_new(a_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
return nativeResponseValue;
}
- // bool DelayedPaymentBasepoint_eq(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR a, const struct LDKDelayedPaymentBasepoint *NONNULL_PTR b);
+ // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
/* @internal */
-export function DelayedPaymentBasepoint_eq(a: bigint, b: bigint): boolean {
+export function ChannelDetails_set_funding_txo(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_eq(a, b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
+ // debug statements here
}
- // uint64_t DelayedPaymentBasepoint_clone_ptr(LDKDelayedPaymentBasepoint *NONNULL_PTR arg);
+ // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentBasepoint_clone_ptr(arg: bigint): bigint {
+export function ChannelDetails_get_channel_type(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
return nativeResponseValue;
}
- // struct LDKDelayedPaymentBasepoint DelayedPaymentBasepoint_clone(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR orig);
+ // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
/* @internal */
-export function DelayedPaymentBasepoint_clone(orig: bigint): bigint {
+export function ChannelDetails_set_channel_type(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
+ // debug statements here
}
- // uint64_t DelayedPaymentBasepoint_hash(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR o);
+ // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentBasepoint_hash(o: bigint): bigint {
+export function ChannelDetails_get_short_channel_id(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_hash(o);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKPublicKey DelayedPaymentBasepoint_to_public_key(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg);
+ // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function DelayedPaymentBasepoint_to_public_key(this_arg: bigint): number {
+export function ChannelDetails_set_short_channel_id(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_to_public_key(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKThirtyTwoBytes DelayedPaymentBasepoint_derive_add_tweak(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR this_arg, struct LDKPublicKey per_commitment_point);
+ // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentBasepoint_derive_add_tweak(this_arg: bigint, per_commitment_point: number): number {
+export function ChannelDetails_get_outbound_scid_alias(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_derive_add_tweak(this_arg, per_commitment_point);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z DelayedPaymentBasepoint_write(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR obj);
+ // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function DelayedPaymentBasepoint_write(obj: bigint): number {
+export function ChannelDetails_set_outbound_scid_alias(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_write(obj);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
+ // debug statements here
}
- // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ DelayedPaymentBasepoint_read(struct LDKu8slice ser);
+ // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentBasepoint_read(ser: number): bigint {
+export function ChannelDetails_get_inbound_scid_alias(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentBasepoint_read(ser);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
return nativeResponseValue;
}
- // void DelayedPaymentKey_free(struct LDKDelayedPaymentKey this_obj);
+ // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function DelayedPaymentKey_free(this_obj: bigint): void {
+export function ChannelDetails_set_inbound_scid_alias(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_free(this_obj);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey DelayedPaymentKey_get_a(const struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr);
+ // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentKey_get_a(this_ptr: bigint): number {
+export function ChannelDetails_get_channel_value_satoshis(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_get_a(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
return nativeResponseValue;
}
- // void DelayedPaymentKey_set_a(struct LDKDelayedPaymentKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function DelayedPaymentKey_set_a(this_ptr: bigint, val: number): void {
+export function ChannelDetails_set_channel_value_satoshis(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_set_a(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_new(struct LDKPublicKey a_arg);
+ // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentKey_new(a_arg: number): bigint {
+export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_new(a_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
return nativeResponseValue;
}
- // bool DelayedPaymentKey_eq(const struct LDKDelayedPaymentKey *NONNULL_PTR a, const struct LDKDelayedPaymentKey *NONNULL_PTR b);
+ // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function DelayedPaymentKey_eq(a: bigint, b: bigint): boolean {
+export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_eq(a, b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
+ // debug statements here
}
- // uint64_t DelayedPaymentKey_clone_ptr(LDKDelayedPaymentKey *NONNULL_PTR arg);
+ // struct LDKU128 ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentKey_clone_ptr(arg: bigint): bigint {
+export function ChannelDetails_get_user_channel_id(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
return nativeResponseValue;
}
- // struct LDKDelayedPaymentKey DelayedPaymentKey_clone(const struct LDKDelayedPaymentKey *NONNULL_PTR orig);
+ // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKU128 val);
/* @internal */
-export function DelayedPaymentKey_clone(orig: bigint): bigint {
+export function ChannelDetails_set_user_channel_id(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_basepoint(const struct LDKDelayedPaymentBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
+ // struct LDKCOption_u32Z ChannelDetails_get_feerate_sat_per_1000_weight(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
+export function ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_feerate_sat_per_1000_weight(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKDelayedPaymentKey DelayedPaymentKey_from_secret_key(const uint8_t (*sk)[32]);
+ // void ChannelDetails_set_feerate_sat_per_1000_weight(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
/* @internal */
-export function DelayedPaymentKey_from_secret_key(sk: number): bigint {
+export function ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_from_secret_key(sk);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_feerate_sat_per_1000_weight(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKPublicKey DelayedPaymentKey_to_public_key(const struct LDKDelayedPaymentKey *NONNULL_PTR this_arg);
+ // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentKey_to_public_key(this_arg: bigint): number {
+export function ChannelDetails_get_balance_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_to_public_key(this_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z DelayedPaymentKey_write(const struct LDKDelayedPaymentKey *NONNULL_PTR obj);
+ // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function DelayedPaymentKey_write(obj: bigint): number {
+export function ChannelDetails_set_balance_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_write(obj);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
+ // debug statements here
}
- // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ DelayedPaymentKey_read(struct LDKu8slice ser);
+ // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function DelayedPaymentKey_read(ser: number): bigint {
+export function ChannelDetails_get_outbound_capacity_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_DelayedPaymentKey_read(ser);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
return nativeResponseValue;
}
- // void HtlcBasepoint_free(struct LDKHtlcBasepoint this_obj);
+ // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function HtlcBasepoint_free(this_obj: bigint): void {
+export function ChannelDetails_set_outbound_capacity_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_free(this_obj);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey HtlcBasepoint_get_a(const struct LDKHtlcBasepoint *NONNULL_PTR this_ptr);
+ // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcBasepoint_get_a(this_ptr: bigint): number {
+export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_get_a(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
return nativeResponseValue;
}
- // void HtlcBasepoint_set_a(struct LDKHtlcBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function HtlcBasepoint_set_a(this_ptr: bigint, val: number): void {
+export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_set_a(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKHtlcBasepoint HtlcBasepoint_new(struct LDKPublicKey a_arg);
+ // uint64_t ChannelDetails_get_next_outbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcBasepoint_new(a_arg: number): bigint {
+export function ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_new(a_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(this_ptr);
return nativeResponseValue;
}
- // bool HtlcBasepoint_eq(const struct LDKHtlcBasepoint *NONNULL_PTR a, const struct LDKHtlcBasepoint *NONNULL_PTR b);
+ // void ChannelDetails_set_next_outbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function HtlcBasepoint_eq(a: bigint, b: bigint): boolean {
+export function ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_eq(a, b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(this_ptr, val);
+ // debug statements here
}
- // uint64_t HtlcBasepoint_clone_ptr(LDKHtlcBasepoint *NONNULL_PTR arg);
+ // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcBasepoint_clone_ptr(arg: bigint): bigint {
+export function ChannelDetails_get_inbound_capacity_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
return nativeResponseValue;
}
- // struct LDKHtlcBasepoint HtlcBasepoint_clone(const struct LDKHtlcBasepoint *NONNULL_PTR orig);
+ // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
/* @internal */
-export function HtlcBasepoint_clone(orig: bigint): bigint {
+export function ChannelDetails_set_inbound_capacity_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
+ // debug statements here
}
- // uint64_t HtlcBasepoint_hash(const struct LDKHtlcBasepoint *NONNULL_PTR o);
+ // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcBasepoint_hash(o: bigint): bigint {
+export function ChannelDetails_get_confirmations_required(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_hash(o);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKPublicKey HtlcBasepoint_to_public_key(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg);
+ // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
/* @internal */
-export function HtlcBasepoint_to_public_key(this_arg: bigint): number {
+export function ChannelDetails_set_confirmations_required(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_to_public_key(this_arg);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKThirtyTwoBytes HtlcBasepoint_derive_add_tweak(const struct LDKHtlcBasepoint *NONNULL_PTR this_arg, struct LDKPublicKey per_commitment_point);
+ // struct LDKCOption_u32Z ChannelDetails_get_confirmations(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcBasepoint_derive_add_tweak(this_arg: bigint, per_commitment_point: number): number {
+export function ChannelDetails_get_confirmations(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_derive_add_tweak(this_arg, per_commitment_point);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations(this_ptr);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z HtlcBasepoint_write(const struct LDKHtlcBasepoint *NONNULL_PTR obj);
+ // void ChannelDetails_set_confirmations(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
/* @internal */
-export function HtlcBasepoint_write(obj: bigint): number {
+export function ChannelDetails_set_confirmations(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_write(obj);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations(this_ptr, val);
+ // debug statements here
}
- // struct LDKCResult_HtlcBasepointDecodeErrorZ HtlcBasepoint_read(struct LDKu8slice ser);
+ // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcBasepoint_read(ser: number): bigint {
+export function ChannelDetails_get_force_close_spend_delay(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcBasepoint_read(ser);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
return nativeResponseValue;
}
- // void HtlcKey_free(struct LDKHtlcKey this_obj);
+ // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
/* @internal */
-export function HtlcKey_free(this_obj: bigint): void {
+export function ChannelDetails_set_force_close_spend_delay(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_free(this_obj);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey HtlcKey_get_a(const struct LDKHtlcKey *NONNULL_PTR this_ptr);
+ // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcKey_get_a(this_ptr: bigint): number {
+export function ChannelDetails_get_is_outbound(this_ptr: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_get_a(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
return nativeResponseValue;
}
- // void HtlcKey_set_a(struct LDKHtlcKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
/* @internal */
-export function HtlcKey_set_a(this_ptr: bigint, val: number): void {
+export function ChannelDetails_set_is_outbound(this_ptr: bigint, val: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_set_a(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKHtlcKey HtlcKey_new(struct LDKPublicKey a_arg);
+ // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcKey_new(a_arg: number): bigint {
+export function ChannelDetails_get_is_channel_ready(this_ptr: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_new(a_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
return nativeResponseValue;
}
- // bool HtlcKey_eq(const struct LDKHtlcKey *NONNULL_PTR a, const struct LDKHtlcKey *NONNULL_PTR b);
+ // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
/* @internal */
-export function HtlcKey_eq(a: bigint, b: bigint): boolean {
+export function ChannelDetails_set_is_channel_ready(this_ptr: bigint, val: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_eq(a, b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
+ // debug statements here
}
- // uint64_t HtlcKey_clone_ptr(LDKHtlcKey *NONNULL_PTR arg);
+ // struct LDKCOption_ChannelShutdownStateZ ChannelDetails_get_channel_shutdown_state(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcKey_clone_ptr(arg: bigint): bigint {
+export function ChannelDetails_get_channel_shutdown_state(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_shutdown_state(this_ptr);
return nativeResponseValue;
}
- // struct LDKHtlcKey HtlcKey_clone(const struct LDKHtlcKey *NONNULL_PTR orig);
+ // void ChannelDetails_set_channel_shutdown_state(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_ChannelShutdownStateZ val);
/* @internal */
-export function HtlcKey_clone(orig: bigint): bigint {
+export function ChannelDetails_set_channel_shutdown_state(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_shutdown_state(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_basepoint(const struct LDKHtlcBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
+ // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
+export function ChannelDetails_get_is_usable(this_ptr: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKHtlcKey HtlcKey_from_secret_key(const uint8_t (*sk)[32]);
+ // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
/* @internal */
-export function HtlcKey_from_secret_key(sk: number): bigint {
+export function ChannelDetails_set_is_usable(this_ptr: bigint, val: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_from_secret_key(sk);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
+ // debug statements here
}
- // MUST_USE_RES struct LDKPublicKey HtlcKey_to_public_key(const struct LDKHtlcKey *NONNULL_PTR this_arg);
+ // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcKey_to_public_key(this_arg: bigint): number {
+export function ChannelDetails_get_is_public(this_ptr: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_to_public_key(this_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z HtlcKey_write(const struct LDKHtlcKey *NONNULL_PTR obj);
+ // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
/* @internal */
-export function HtlcKey_write(obj: bigint): number {
+export function ChannelDetails_set_is_public(this_ptr: bigint, val: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_write(obj);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
+ // debug statements here
}
- // struct LDKCResult_HtlcKeyDecodeErrorZ HtlcKey_read(struct LDKu8slice ser);
+ // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function HtlcKey_read(ser: number): bigint {
+export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_HtlcKey_read(ser);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
return nativeResponseValue;
}
- // struct LDKPublicKey add_public_key_tweak(struct LDKPublicKey base_point, const uint8_t (*tweak)[32]);
+ // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function add_public_key_tweak(base_point: number, tweak: number): number {
+export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_add_public_key_tweak(base_point, tweak);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
return nativeResponseValue;
}
- // void RevocationBasepoint_free(struct LDKRevocationBasepoint this_obj);
+ // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
/* @internal */
-export function RevocationBasepoint_free(this_obj: bigint): void {
+export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_free(this_obj);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
// debug statements here
}
- // struct LDKPublicKey RevocationBasepoint_get_a(const struct LDKRevocationBasepoint *NONNULL_PTR this_ptr);
+ // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function RevocationBasepoint_get_a(this_ptr: bigint): number {
+export function ChannelDetails_get_config(this_ptr: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_get_a(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
return nativeResponseValue;
}
- // void RevocationBasepoint_set_a(struct LDKRevocationBasepoint *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
/* @internal */
-export function RevocationBasepoint_set_a(this_ptr: bigint, val: number): void {
+export function ChannelDetails_set_config(this_ptr: bigint, val: bigint): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_set_a(this_ptr, val);
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKRevocationBasepoint RevocationBasepoint_new(struct LDKPublicKey a_arg);
+ // struct LDKCVec_InboundHTLCDetailsZ ChannelDetails_get_pending_inbound_htlcs(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function RevocationBasepoint_new(a_arg: number): bigint {
+export function ChannelDetails_get_pending_inbound_htlcs(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_new(a_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_pending_inbound_htlcs(this_ptr);
return nativeResponseValue;
}
- // bool RevocationBasepoint_eq(const struct LDKRevocationBasepoint *NONNULL_PTR a, const struct LDKRevocationBasepoint *NONNULL_PTR b);
+ // void ChannelDetails_set_pending_inbound_htlcs(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCVec_InboundHTLCDetailsZ val);
/* @internal */
-export function RevocationBasepoint_eq(a: bigint, b: bigint): boolean {
+export function ChannelDetails_set_pending_inbound_htlcs(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_eq(a, b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_pending_inbound_htlcs(this_ptr, val);
+ // debug statements here
}
- // uint64_t RevocationBasepoint_clone_ptr(LDKRevocationBasepoint *NONNULL_PTR arg);
+ // struct LDKCVec_OutboundHTLCDetailsZ ChannelDetails_get_pending_outbound_htlcs(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
/* @internal */
-export function RevocationBasepoint_clone_ptr(arg: bigint): bigint {
+export function ChannelDetails_get_pending_outbound_htlcs(this_ptr: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_pending_outbound_htlcs(this_ptr);
return nativeResponseValue;
}
- // struct LDKRevocationBasepoint RevocationBasepoint_clone(const struct LDKRevocationBasepoint *NONNULL_PTR orig);
+ // void ChannelDetails_set_pending_outbound_htlcs(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCVec_OutboundHTLCDetailsZ val);
/* @internal */
-export function RevocationBasepoint_clone(orig: bigint): bigint {
+export function ChannelDetails_set_pending_outbound_htlcs(this_ptr: bigint, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.TS_ChannelDetails_set_pending_outbound_htlcs(this_ptr, val);
+ // debug statements here
}
- // uint64_t RevocationBasepoint_hash(const struct LDKRevocationBasepoint *NONNULL_PTR o);
+ // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKChannelId channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, struct LDKU128 user_channel_id_arg, struct LDKCOption_u32Z feerate_sat_per_1000_weight_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t next_outbound_htlc_minimum_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u32Z confirmations_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, struct LDKCOption_ChannelShutdownStateZ channel_shutdown_state_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg, struct LDKCVec_InboundHTLCDetailsZ pending_inbound_htlcs_arg, struct LDKCVec_OutboundHTLCDetailsZ pending_outbound_htlcs_arg);
/* @internal */
-export function RevocationBasepoint_hash(o: bigint): bigint {
+export function ChannelDetails_new(channel_id_arg: bigint, counterparty_arg: bigint, funding_txo_arg: bigint, channel_type_arg: bigint, short_channel_id_arg: bigint, outbound_scid_alias_arg: bigint, inbound_scid_alias_arg: bigint, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: bigint, user_channel_id_arg: number, feerate_sat_per_1000_weight_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, next_outbound_htlc_minimum_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: bigint, confirmations_arg: bigint, force_close_spend_delay_arg: bigint, is_outbound_arg: boolean, is_channel_ready_arg: boolean, channel_shutdown_state_arg: bigint, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: bigint, inbound_htlc_maximum_msat_arg: bigint, config_arg: bigint, pending_inbound_htlcs_arg: number, pending_outbound_htlcs_arg: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_hash(o);
+ const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, feerate_sat_per_1000_weight_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, next_outbound_htlc_minimum_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, confirmations_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, channel_shutdown_state_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg, pending_inbound_htlcs_arg, pending_outbound_htlcs_arg);
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKPublicKey RevocationBasepoint_to_public_key(const struct LDKRevocationBasepoint *NONNULL_PTR this_arg);
+ // uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
/* @internal */
-export function RevocationBasepoint_to_public_key(this_arg: bigint): number {
+export function ChannelDetails_clone_ptr(arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_to_public_key(this_arg);
+ const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z RevocationBasepoint_write(const struct LDKRevocationBasepoint *NONNULL_PTR obj);
+ // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
/* @internal */
-export function RevocationBasepoint_write(obj: bigint): number {
+export function ChannelDetails_clone(orig: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_write(obj);
+ const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RevocationBasepointDecodeErrorZ RevocationBasepoint_read(struct LDKu8slice ser);
+ // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
/* @internal */
-export function RevocationBasepoint_read(ser: number): bigint {
+export function ChannelDetails_get_inbound_payment_scid(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationBasepoint_read(ser);
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
return nativeResponseValue;
}
- // void RevocationKey_free(struct LDKRevocationKey this_obj);
+ // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
/* @internal */
-export function RevocationKey_free(this_obj: bigint): void {
+export function ChannelDetails_get_outbound_payment_scid(this_arg: bigint): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_free(this_obj);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
+ return nativeResponseValue;
}
- // struct LDKPublicKey RevocationKey_get_a(const struct LDKRevocationKey *NONNULL_PTR this_ptr);
+ // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
/* @internal */
-export function RevocationKey_get_a(this_ptr: bigint): number {
+export function ChannelDetails_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_get_a(this_ptr);
+ const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
return nativeResponseValue;
}
- // void RevocationKey_set_a(struct LDKRevocationKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+ // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
/* @internal */
-export function RevocationKey_set_a(this_ptr: bigint, val: number): void {
+export function ChannelDetails_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_set_a(this_ptr, val);
- // debug statements here
+ const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
+ return nativeResponseValue;
}
- // MUST_USE_RES struct LDKRevocationKey RevocationKey_new(struct LDKPublicKey a_arg);
+ // enum LDKChannelShutdownState ChannelShutdownState_clone(const enum LDKChannelShutdownState *NONNULL_PTR orig);
/* @internal */
-export function RevocationKey_new(a_arg: number): bigint {
+export function ChannelShutdownState_clone(orig: bigint): ChannelShutdownState {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_new(a_arg);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_clone(orig);
return nativeResponseValue;
}
- // bool RevocationKey_eq(const struct LDKRevocationKey *NONNULL_PTR a, const struct LDKRevocationKey *NONNULL_PTR b);
+ // enum LDKChannelShutdownState ChannelShutdownState_not_shutting_down(void);
/* @internal */
-export function RevocationKey_eq(a: bigint, b: bigint): boolean {
+export function ChannelShutdownState_not_shutting_down(): ChannelShutdownState {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_eq(a, b);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_not_shutting_down();
return nativeResponseValue;
}
- // uint64_t RevocationKey_clone_ptr(LDKRevocationKey *NONNULL_PTR arg);
+ // enum LDKChannelShutdownState ChannelShutdownState_shutdown_initiated(void);
/* @internal */
-export function RevocationKey_clone_ptr(arg: bigint): bigint {
+export function ChannelShutdownState_shutdown_initiated(): ChannelShutdownState {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_clone_ptr(arg);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_initiated();
return nativeResponseValue;
}
- // struct LDKRevocationKey RevocationKey_clone(const struct LDKRevocationKey *NONNULL_PTR orig);
+ // enum LDKChannelShutdownState ChannelShutdownState_resolving_htlcs(void);
/* @internal */
-export function RevocationKey_clone(orig: bigint): bigint {
+export function ChannelShutdownState_resolving_htlcs(): ChannelShutdownState {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_clone(orig);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_resolving_htlcs();
return nativeResponseValue;
}
- // uint64_t RevocationKey_hash(const struct LDKRevocationKey *NONNULL_PTR o);
+ // enum LDKChannelShutdownState ChannelShutdownState_negotiating_closing_fee(void);
/* @internal */
-export function RevocationKey_hash(o: bigint): bigint {
+export function ChannelShutdownState_negotiating_closing_fee(): ChannelShutdownState {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_hash(o);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_negotiating_closing_fee();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKRevocationKey RevocationKey_from_basepoint(const struct LDKRevocationBasepoint *NONNULL_PTR countersignatory_basepoint, struct LDKPublicKey per_commitment_point);
+ // enum LDKChannelShutdownState ChannelShutdownState_shutdown_complete(void);
/* @internal */
-export function RevocationKey_from_basepoint(countersignatory_basepoint: bigint, per_commitment_point: number): bigint {
+export function ChannelShutdownState_shutdown_complete(): ChannelShutdownState {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_from_basepoint(countersignatory_basepoint, per_commitment_point);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_shutdown_complete();
return nativeResponseValue;
}
- // MUST_USE_RES struct LDKPublicKey RevocationKey_to_public_key(const struct LDKRevocationKey *NONNULL_PTR this_arg);
+ // bool ChannelShutdownState_eq(const enum LDKChannelShutdownState *NONNULL_PTR a, const enum LDKChannelShutdownState *NONNULL_PTR b);
/* @internal */
-export function RevocationKey_to_public_key(this_arg: bigint): number {
+export function ChannelShutdownState_eq(a: bigint, b: bigint): boolean {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_to_public_key(this_arg);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_eq(a, b);
return nativeResponseValue;
}
- // struct LDKCVec_u8Z RevocationKey_write(const struct LDKRevocationKey *NONNULL_PTR obj);
+ // struct LDKCVec_u8Z ChannelShutdownState_write(const enum LDKChannelShutdownState *NONNULL_PTR obj);
/* @internal */
-export function RevocationKey_write(obj: bigint): number {
+export function ChannelShutdownState_write(obj: bigint): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_write(obj);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_write(obj);
return nativeResponseValue;
}
- // struct LDKCResult_RevocationKeyDecodeErrorZ RevocationKey_read(struct LDKu8slice ser);
+ // struct LDKCResult_ChannelShutdownStateDecodeErrorZ ChannelShutdownState_read(struct LDKu8slice ser);
/* @internal */
-export function RevocationKey_read(ser: number): bigint {
+export function ChannelShutdownState_read(ser: number): bigint {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TS_RevocationKey_read(ser);
+ const nativeResponseValue = wasm.TS_ChannelShutdownState_read(ser);
return nativeResponseValue;
}
// void ExpandedKey_free(struct LDKExpandedKey this_obj);
}
const nativeResponseValue = wasm.TS_SocketAddressParseError_eq(a, b);
return nativeResponseValue;
+}
+ // struct LDKStr SocketAddressParseError_to_str(const enum LDKSocketAddressParseError *NONNULL_PTR o);
+/* @internal */
+export function SocketAddressParseError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SocketAddressParseError_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCResult_SocketAddressSocketAddressParseErrorZ parse_onion_address(struct LDKStr host, uint16_t port);
/* @internal */
}
const nativeResponseValue = wasm.TS_TrampolineOnionPacket_write(obj);
return nativeResponseValue;
+}
+ // struct LDKStr DecodeError_to_str(const struct LDKDecodeError *NONNULL_PTR o);
+/* @internal */
+export function DecodeError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_DecodeError_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
return nativeResponseValue;
+}
+ // struct LDKStr PeerHandleError_to_str(const struct LDKPeerHandleError *NONNULL_PTR o);
+/* @internal */
+export function PeerHandleError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PeerHandleError_to_str(o);
+ return nativeResponseValue;
}
// void PeerManager_free(struct LDKPeerManager this_obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
return nativeResponseValue;
+}
+ // struct LDKStr ShutdownScript_to_str(const struct LDKShutdownScript *NONNULL_PTR o);
+/* @internal */
+export function ShutdownScript_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ShutdownScript_to_str(o);
+ return nativeResponseValue;
}
// void ChannelId_free(struct LDKChannelId this_obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_ChannelId_read(ser);
return nativeResponseValue;
+}
+ // struct LDKStr ChannelId_to_str(const struct LDKChannelId *NONNULL_PTR o);
+/* @internal */
+export function ChannelId_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelId_to_str(o);
+ return nativeResponseValue;
}
// void Retry_free(struct LDKRetry this_ptr);
/* @internal */
}
const nativeResponseValue = wasm.TS_Offer_from_str(s);
return nativeResponseValue;
+}
+ // struct LDKStr Offer_to_str(const struct LDKOffer *NONNULL_PTR o);
+/* @internal */
+export function Offer_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Offer_to_str(o);
+ return nativeResponseValue;
}
// void InvoiceWithExplicitSigningPubkeyBuilder_free(struct LDKInvoiceWithExplicitSigningPubkeyBuilder this_obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_InvoiceError_from_string(s);
return nativeResponseValue;
+}
+ // struct LDKStr InvoiceError_to_str(const struct LDKInvoiceError *NONNULL_PTR o);
+/* @internal */
+export function InvoiceError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_InvoiceError_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z InvoiceError_write(const struct LDKInvoiceError *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_Refund_from_str(s);
return nativeResponseValue;
+}
+ // struct LDKStr Refund_to_str(const struct LDKRefund *NONNULL_PTR o);
+/* @internal */
+export function Refund_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Refund_to_str(o);
+ return nativeResponseValue;
}
// enum LDKUtxoLookupError UtxoLookupError_clone(const enum LDKUtxoLookupError *NONNULL_PTR orig);
/* @internal */
}
const nativeResponseValue = wasm.TS_NodeId_as_pubkey(this_arg);
return nativeResponseValue;
+}
+ // struct LDKStr NodeId_to_str(const struct LDKNodeId *NONNULL_PTR o);
+/* @internal */
+export function NodeId_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeId_to_str(o);
+ return nativeResponseValue;
}
// uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
/* @internal */
}
const nativeResponseValue = wasm.TS_ChannelUpdateInfo_eq(a, b);
return nativeResponseValue;
+}
+ // struct LDKStr ChannelUpdateInfo_to_str(const struct LDKChannelUpdateInfo *NONNULL_PTR o);
+/* @internal */
+export function ChannelUpdateInfo_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelUpdateInfo_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
return nativeResponseValue;
+}
+ // struct LDKStr ChannelInfo_to_str(const struct LDKChannelInfo *NONNULL_PTR o);
+/* @internal */
+export function ChannelInfo_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelInfo_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_NodeAlias_eq(a, b);
return nativeResponseValue;
+}
+ // struct LDKStr NodeAlias_to_str(const struct LDKNodeAlias *NONNULL_PTR o);
+/* @internal */
+export function NodeAlias_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeAlias_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_NodeInfo_is_tor_only(this_arg);
return nativeResponseValue;
+}
+ // struct LDKStr NodeInfo_to_str(const struct LDKNodeInfo *NONNULL_PTR o);
+/* @internal */
+export function NodeInfo_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NodeInfo_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
return nativeResponseValue;
+}
+ // struct LDKStr NetworkGraph_to_str(const struct LDKNetworkGraph *NONNULL_PTR o);
+/* @internal */
+export function NetworkGraph_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_NetworkGraph_to_str(o);
+ return nativeResponseValue;
}
// MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(enum LDKNetwork network, struct LDKLogger logger);
/* @internal */
}
const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
return nativeResponseValue;
+}
+ // struct LDKStr Route_to_str(const struct LDKRoute *NONNULL_PTR o);
+/* @internal */
+export function Route_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Route_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
/* @internal */
}
const nativeResponseValue = wasm.TS_ClosureReason_eq(a, b);
return nativeResponseValue;
+}
+ // struct LDKStr ClosureReason_to_str(const struct LDKClosureReason *NONNULL_PTR o);
+/* @internal */
+export function ClosureReason_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ClosureReason_to_str(o);
+ return nativeResponseValue;
}
// struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
/* @internal */
projects / ldk-java / blobdiff