+class CVec_TxOutZ;
+class CVec_InboundHTLCDetailsZ;
+class CVec_OutboundHTLCDetailsZ;
+class CResult_BuiltCommitmentTransactionDecodeErrorZ;
+class CVec_PaymentForwardNodeZ;
+class CResult_TrackedSpendableOutputDecodeErrorZ;
+class CVec_SpendableOutputDescriptorZ;
+class CResult_ResponderDecodeErrorZ;
+class C2Tuple_OutPointCVec_u8ZZ;
+class CResult_WitnessNoneZ;
+class COption_C2Tuple_u64u64ZZ;
+class CResult_ChannelAnnouncementDecodeErrorZ;
+class CResult_HTLCUpdateDecodeErrorZ;
+class CResult_TxAddInputDecodeErrorZ;
+class CResult_HeldHtlcAvailableDecodeErrorZ;
+class CResult_TxInitRbfDecodeErrorZ;
+class COption_WriteableScoreZ;
+class CVec_StrZ;
+class CResult_AsyncPaymentsMessageDecodeErrorZ;
+class CResult_SpliceAckDecodeErrorZ;
+class CResult_PositiveTimestampCreationErrorZ;
+class CResult_PeeledOnionNoneZ;
+class CVec_C2Tuple_OutPointChannelIdZZ;
+class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class CResult_ReplyChannelRangeDecodeErrorZ;
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
+class CResult_TrustedClosingTransactionNoneZ;
+class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
+class C2Tuple_PublicKeyTypeZ;
+class CResult_TxRemoveOutputDecodeErrorZ;
+class CResult_ChannelReestablishDecodeErrorZ;
+class CResult_OnionMessageDecodeErrorZ;
+class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
+class CResult_MessageContextDecodeErrorZ;
+class CResult_InitFeaturesDecodeErrorZ;
+class CResult_PublicKeyNoneZ;
+class CResult_PingDecodeErrorZ;
+class CResult_RevocationKeyDecodeErrorZ;
+class C2Tuple_OffersMessageMessageSendInstructionsZ;
+class CResult_BlindedHopFeaturesDecodeErrorZ;
+class CResult_ChannelIdDecodeErrorZ;
+class CVec_TransactionOutputsZ;
+class COption_HTLCClaimZ;
+class COption_boolZ;
+class CVec_BlindedPaymentPathZ;
+class CResult_ProbabilisticScorerDecodeErrorZ;
+class COption_StrZ;
+class CResult_CVec_BlindedPaymentPathZNoneZ;
+class COption_C2Tuple_OffersMessageResponseInstructionZZ;
+class C2Tuple_usizeTransactionZ;
+class COption_OffersContextZ;
+class CResult_NodeAnnouncementDecodeErrorZ;
+class CVec_ChannelMonitorZ;
+class CResult_AcceptChannelV2DecodeErrorZ;
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ;
+class CResult_RouteHopDecodeErrorZ;
+class CResult_OfferIdDecodeErrorZ;
+class CVec_HTLCOutputInCommitmentZ;
+class CResult_CoinSelectionNoneZ;
+class CVec_FutureZ;
+class CResult_TxCreationKeysDecodeErrorZ;
+class CResult_RefundBolt12SemanticErrorZ;
+class CResult_NoneIOErrorZ;
+class CResult_MaxDustHTLCExposureDecodeErrorZ;
+class CVec_BalanceZ;
+class CVec_CommitmentTransactionZ;
+class CResult_FundingSignedDecodeErrorZ;
+class CResult_RecoverableSignatureNoneZ;
+class CResult_SocketAddressDecodeErrorZ;
+class C2Tuple_Z;
+class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_InboundHTLCDetailsDecodeErrorZ;
+class CResult_SiPrefixBolt11ParseErrorZ;
+class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
+class CVec_PathZ;
+class CResult_NetworkGraphDecodeErrorZ;
+class CResult_NodeInfoDecodeErrorZ;
+class CVec_NodeIdZ;
+class CVec_u8Z;
+class CResult_RouteLightningErrorZ;
+class CResult_NonePaymentSendFailureZ;
+class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
+class CResult_ChannelPublicKeysDecodeErrorZ;
+class CVec_ClaimedHTLCZ;
+class COption_CVec_ThirtyTwoBytesZZ;
+class CVec_SocketAddressZ;
+class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ;
+class CResult_ThirtyTwoBytesPaymentSendFailureZ;
+class CResult_WarningMessageDecodeErrorZ;
+class CResult_ChannelCounterpartyDecodeErrorZ;
+class CResult_HolderCommitmentTransactionDecodeErrorZ;
+class CResult_DelayedPaymentKeyDecodeErrorZ;
+class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
+class CResult_OfferBolt12SemanticErrorZ;
+class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
+class CResult_InitDecodeErrorZ;
+class CResult_PaymentPurposeDecodeErrorZ;
+class CResult_ClaimedHTLCDecodeErrorZ;
+class CResult_OutPointDecodeErrorZ;
+class CVec_ChannelDetailsZ;
+class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
+class CVec_MessageSendEventZ;
+class CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ;
+class CResult_RouteHintHopDecodeErrorZ;
+class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ;
+class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
+class CResult_BlindedPayInfoDecodeErrorZ;
+class CResult_ThirtyTwoBytesAPIErrorZ;
+class COption_ChannelShutdownStateZ;
+class CResult_Bolt12InvoiceBolt12SemanticErrorZ;
+class CResult_InvoiceRequestFieldsDecodeErrorZ;
+class CResult_AcceptChannelDecodeErrorZ;
+class CResult_RefundDecodeErrorZ;
+class CResult_HostnameDecodeErrorZ;
+class C2Tuple_u64u16Z;
+class COption_ThirtyTwoBytesZ;
+class CVec_u64Z;
+class CResult_NoneBolt12SemanticErrorZ;
+class CResult_UnknownPaymentContextDecodeErrorZ;
+class COption_InboundHTLCStateDetailsZ;
+class CResult_OutputSweeperDecodeErrorZ;
+class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
+class COption_EventZ;
+class CResult_ChannelTypeFeaturesDecodeErrorZ;
+class COption_CVec_SocketAddressZZ;
+class CVec_RouteHintZ;
+class COption_u16Z;
+class COption_PaymentFailureReasonZ;
+class CResult_Bolt12RefundContextDecodeErrorZ;
+class CResult_ECDSASignatureNoneZ;
+class C2Tuple_ChannelIdPublicKeyZ;
+class C2Tuple_OffersMessageResponseInstructionZ;
+class CResult_EcdsaChannelSignerDecodeErrorZ;
+class CResult_BlindedTailDecodeErrorZ;
+class CVec_WitnessZ;
+class COption_C2Tuple_u64u16ZZ;
+class CResult_SocketAddressSocketAddressParseErrorZ;
+class CResult_COption_PaymentFailureReasonZDecodeErrorZ;
+class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
+class CResult_ChannelDerivationParametersDecodeErrorZ;
+class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
+class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ;
+class CResult_OnionMessagePathNoneZ;
+class C2Tuple_u32CVec_u8ZZ;
+class CVec_C2Tuple_PublicKeyTypeZZ;
+class CResult_OutboundHTLCDetailsDecodeErrorZ;
+class CResult_RefundBolt12ParseErrorZ;
+class CResult_u32GraphSyncErrorZ;
+class CVec_C2Tuple_u64CVec_u8ZZZ;
+class CResult_OffersMessageDecodeErrorZ;
+class CResult_PaymentConstraintsDecodeErrorZ;
+class CResult_NoneAPIErrorZ;
+class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
+class COption_f64Z;
+class CResult_TxRemoveInputDecodeErrorZ;
+class CVec_PublicKeyZ;
+class C2Tuple_CVec_u8Zu64Z;
+class CVec_C2Tuple_usizeTransactionZZ;
+class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
+class CResult_Bolt12InvoiceDecodeErrorZ;
+class C2Tuple_u64u64Z;
+class COption_NodeAnnouncementInfoZ;
+class CResult_PendingHTLCRoutingDecodeErrorZ;
+class COption_C2Tuple_OnionMessageContentsResponseInstructionZZ;
+class CResult_RecipientOnionFieldsDecodeErrorZ;
+class C2Tuple_u32TxOutZ;
+class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ;
+class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ;
+class CResult_ChannelDetailsDecodeErrorZ;
+class CVec_UtxoZ;
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
+class CResult_ChannelConfigDecodeErrorZ;
+class CVec_PrivateRouteZ;
+class COption_i64Z;
+class CResult_PaymentContextDecodeErrorZ;
+class CVec_PhantomRouteHintsZ;
+class CVec_C2Tuple_OutPointCVec_u64ZZZ;
+class C2Tuple_ThirtyTwoBytesChannelManagerZ;
+class CResult_COption_OnionMessageContentsZDecodeErrorZ;
+class C2Tuple_u64CVec_u8ZZ;
+class CResult_OfferBolt12ParseErrorZ;
+class CResult_ThirtyTwoBytesRetryableSendFailureZ;
+class CVec_MonitorEventZ;
+class CResult_ShutdownDecodeErrorZ;
+class CResult_BigSizeDecodeErrorZ;
+class CResult_TxOutUtxoLookupErrorZ;
+class COption_usizeZ;
+class CVec_BlindedMessagePathZ;
+class CResult_OffersContextDecodeErrorZ;
+class CResult_NoneNoneZ;
+class CResult_boolPeerHandleErrorZ;
+class CResult_ChannelUpdateDecodeErrorZ;
+class CVec_APIErrorZ;
+class COption_TxOutZ;
+class COption_ClosureReasonZ;
+class CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ;
+class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
+class CResult_TransactionU16LenLimitedDecodeErrorZ;
+class CResult_FundingInfoDecodeErrorZ;
+class COption_AmountZ;
+class COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ;
+class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
+class CResult_OpenChannelV2DecodeErrorZ;
+class CResult_BestBlockDecodeErrorZ;
+class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
+class CResult_CounterpartyForwardingInfoDecodeErrorZ;
+class CResult_OutputSpendStatusDecodeErrorZ;
+class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ;
+class CResult_RouteDecodeErrorZ;
+class CResult_BlindedFailureDecodeErrorZ;
+class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
+class COption_NoneZ;
+class CResult_SpliceLockedDecodeErrorZ;
+class COption_CVec_u8ZZ;
+class COption_QuantityZ;
+class CResult_TxAddOutputDecodeErrorZ;
+class CResult_HtlcBasepointDecodeErrorZ;
+class C2Tuple_OutPointChannelIdZ;
+
+class Str {
+private:
+ LDKStr self;
+public:
+ Str(const Str&) = delete;
+ Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
+ Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
+ operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
+ ~Str() { Str_free(self); }
+ Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
+ LDKStr* operator &() { return &self; }
+ LDKStr* operator ->() { return &self; }
+ const LDKStr* operator &() const { return &self; }
+ const LDKStr* operator ->() const { return &self; }
+};
+class RefundMaybeWithDerivedMetadataBuilder {
+private:
+ LDKRefundMaybeWithDerivedMetadataBuilder self;
+public:
+ RefundMaybeWithDerivedMetadataBuilder(const RefundMaybeWithDerivedMetadataBuilder&) = delete;
+ RefundMaybeWithDerivedMetadataBuilder(RefundMaybeWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); }
+ RefundMaybeWithDerivedMetadataBuilder(LDKRefundMaybeWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); }
+ operator LDKRefundMaybeWithDerivedMetadataBuilder() && { LDKRefundMaybeWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); return res; }
+ ~RefundMaybeWithDerivedMetadataBuilder() { RefundMaybeWithDerivedMetadataBuilder_free(self); }
+ RefundMaybeWithDerivedMetadataBuilder& operator=(RefundMaybeWithDerivedMetadataBuilder&& o) { RefundMaybeWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); return *this; }
+ LDKRefundMaybeWithDerivedMetadataBuilder* operator &() { return &self; }
+ LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() { return &self; }
+ const LDKRefundMaybeWithDerivedMetadataBuilder* operator &() const { return &self; }
+ const LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() const { return &self; }
+};
+class Refund {
+private:
+ LDKRefund self;
+public:
+ Refund(const Refund&) = delete;
+ Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
+ Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
+ operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
+ ~Refund() { Refund_free(self); }
+ Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
+ LDKRefund* operator &() { return &self; }
+ LDKRefund* operator ->() { return &self; }
+ const LDKRefund* operator &() const { return &self; }
+ const LDKRefund* operator ->() const { return &self; }
+};
+class Retry {
+private:
+ LDKRetry self;
+public:
+ Retry(const Retry&) = delete;
+ Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
+ Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
+ operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
+ ~Retry() { Retry_free(self); }
+ Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
+ LDKRetry* operator &() { return &self; }
+ LDKRetry* operator ->() { return &self; }
+ const LDKRetry* operator &() const { return &self; }
+ const LDKRetry* operator ->() const { return &self; }
+};
+class RetryableSendFailure {
+private:
+ LDKRetryableSendFailure self;
+public:
+ RetryableSendFailure(const RetryableSendFailure&) = delete;
+ RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
+ RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
+ operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
+ RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
+ LDKRetryableSendFailure* operator &() { return &self; }
+ LDKRetryableSendFailure* operator ->() { return &self; }
+ const LDKRetryableSendFailure* operator &() const { return &self; }
+ const LDKRetryableSendFailure* operator ->() const { return &self; }
+};
+class PaymentSendFailure {
+private:
+ LDKPaymentSendFailure self;
+public:
+ PaymentSendFailure(const PaymentSendFailure&) = delete;
+ PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
+ PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
+ operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
+ ~PaymentSendFailure() { PaymentSendFailure_free(self); }
+ PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
+ LDKPaymentSendFailure* operator &() { return &self; }
+ LDKPaymentSendFailure* operator ->() { return &self; }
+ const LDKPaymentSendFailure* operator &() const { return &self; }
+ const LDKPaymentSendFailure* operator ->() const { return &self; }
+};
+class Bolt12PaymentError {
+private:
+ LDKBolt12PaymentError self;
+public:
+ Bolt12PaymentError(const Bolt12PaymentError&) = delete;
+ Bolt12PaymentError(Bolt12PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12PaymentError)); }
+ Bolt12PaymentError(LDKBolt12PaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12PaymentError)); }
+ operator LDKBolt12PaymentError() && { LDKBolt12PaymentError res = self; memset(&self, 0, sizeof(LDKBolt12PaymentError)); return res; }
+ ~Bolt12PaymentError() { Bolt12PaymentError_free(self); }
+ Bolt12PaymentError& operator=(Bolt12PaymentError&& o) { Bolt12PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12PaymentError)); return *this; }
+ LDKBolt12PaymentError* operator &() { return &self; }
+ LDKBolt12PaymentError* operator ->() { return &self; }
+ const LDKBolt12PaymentError* operator &() const { return &self; }
+ const LDKBolt12PaymentError* operator ->() const { return &self; }
+};
+class ProbeSendFailure {
+private:
+ LDKProbeSendFailure self;
+public:
+ ProbeSendFailure(const ProbeSendFailure&) = delete;
+ ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
+ ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
+ operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
+ ~ProbeSendFailure() { ProbeSendFailure_free(self); }
+ ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
+ LDKProbeSendFailure* operator &() { return &self; }
+ LDKProbeSendFailure* operator ->() { return &self; }
+ const LDKProbeSendFailure* operator &() const { return &self; }
+ const LDKProbeSendFailure* operator ->() const { return &self; }
+};
+class RecipientOnionFields {
+private:
+ LDKRecipientOnionFields self;
+public:
+ RecipientOnionFields(const RecipientOnionFields&) = delete;
+ RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
+ RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
+ operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
+ ~RecipientOnionFields() { RecipientOnionFields_free(self); }
+ RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
+ LDKRecipientOnionFields* operator &() { return &self; }
+ LDKRecipientOnionFields* operator ->() { return &self; }
+ const LDKRecipientOnionFields* operator &() const { return &self; }
+ const LDKRecipientOnionFields* operator ->() const { return &self; }
+};
+class InvoiceWithExplicitSigningPubkeyBuilder {
+private:
+ LDKInvoiceWithExplicitSigningPubkeyBuilder self;
+public:
+ InvoiceWithExplicitSigningPubkeyBuilder(const InvoiceWithExplicitSigningPubkeyBuilder&) = delete;
+ InvoiceWithExplicitSigningPubkeyBuilder(InvoiceWithExplicitSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); }
+ InvoiceWithExplicitSigningPubkeyBuilder(LDKInvoiceWithExplicitSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); }
+ operator LDKInvoiceWithExplicitSigningPubkeyBuilder() && { LDKInvoiceWithExplicitSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); return res; }
+ ~InvoiceWithExplicitSigningPubkeyBuilder() { InvoiceWithExplicitSigningPubkeyBuilder_free(self); }
+ InvoiceWithExplicitSigningPubkeyBuilder& operator=(InvoiceWithExplicitSigningPubkeyBuilder&& o) { InvoiceWithExplicitSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); return *this; }
+ LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() { return &self; }
+ LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() { return &self; }
+ const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() const { return &self; }
+ const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() const { return &self; }
+};
+class InvoiceWithDerivedSigningPubkeyBuilder {
+private:
+ LDKInvoiceWithDerivedSigningPubkeyBuilder self;
+public:
+ InvoiceWithDerivedSigningPubkeyBuilder(const InvoiceWithDerivedSigningPubkeyBuilder&) = delete;
+ InvoiceWithDerivedSigningPubkeyBuilder(InvoiceWithDerivedSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); }
+ InvoiceWithDerivedSigningPubkeyBuilder(LDKInvoiceWithDerivedSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); }
+ operator LDKInvoiceWithDerivedSigningPubkeyBuilder() && { LDKInvoiceWithDerivedSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); return res; }
+ ~InvoiceWithDerivedSigningPubkeyBuilder() { InvoiceWithDerivedSigningPubkeyBuilder_free(self); }
+ InvoiceWithDerivedSigningPubkeyBuilder& operator=(InvoiceWithDerivedSigningPubkeyBuilder&& o) { InvoiceWithDerivedSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); return *this; }
+ LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() { return &self; }
+ LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() { return &self; }
+ const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() const { return &self; }
+ const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() const { return &self; }
+};
+class UnsignedBolt12Invoice {
+private:
+ LDKUnsignedBolt12Invoice self;
+public:
+ UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
+ UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
+ UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
+ operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
+ ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
+ UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
+ LDKUnsignedBolt12Invoice* operator &() { return &self; }
+ LDKUnsignedBolt12Invoice* operator ->() { return &self; }
+ const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
+ const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
+};
+class SignBolt12InvoiceFn {
+private:
+ LDKSignBolt12InvoiceFn self;
+public:
+ SignBolt12InvoiceFn(const SignBolt12InvoiceFn&) = delete;
+ SignBolt12InvoiceFn(SignBolt12InvoiceFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignBolt12InvoiceFn)); }
+ SignBolt12InvoiceFn(LDKSignBolt12InvoiceFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignBolt12InvoiceFn)); }
+ operator LDKSignBolt12InvoiceFn() && { LDKSignBolt12InvoiceFn res = self; memset(&self, 0, sizeof(LDKSignBolt12InvoiceFn)); return res; }
+ ~SignBolt12InvoiceFn() { SignBolt12InvoiceFn_free(self); }
+ SignBolt12InvoiceFn& operator=(SignBolt12InvoiceFn&& o) { SignBolt12InvoiceFn_free(self); self = o.self; memset(&o, 0, sizeof(SignBolt12InvoiceFn)); return *this; }
+ LDKSignBolt12InvoiceFn* operator &() { return &self; }
+ LDKSignBolt12InvoiceFn* operator ->() { return &self; }
+ const LDKSignBolt12InvoiceFn* operator &() const { return &self; }
+ const LDKSignBolt12InvoiceFn* operator ->() const { return &self; }
+ /**
+ * Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message);
+};
+class Bolt12Invoice {
+private:
+ LDKBolt12Invoice self;
+public:
+ Bolt12Invoice(const Bolt12Invoice&) = delete;
+ Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
+ Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
+ operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
+ ~Bolt12Invoice() { Bolt12Invoice_free(self); }
+ Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
+ LDKBolt12Invoice* operator &() { return &self; }
+ LDKBolt12Invoice* operator ->() { return &self; }
+ const LDKBolt12Invoice* operator &() const { return &self; }
+ const LDKBolt12Invoice* operator ->() const { return &self; }
+};
+class DelayedPaymentOutputDescriptor {
+private:
+ LDKDelayedPaymentOutputDescriptor self;
+public:
+ DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
+ DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
+ DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
+ operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
+ ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
+ DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
+ LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
+ LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
+ const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
+ const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
+};
+class StaticPaymentOutputDescriptor {
+private:
+ LDKStaticPaymentOutputDescriptor self;
+public:
+ StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
+ StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
+ StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
+ operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
+ ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
+ StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
+ LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
+ LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
+ const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
+ const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
+};
+class SpendableOutputDescriptor {
+private:
+ LDKSpendableOutputDescriptor self;
+public:
+ SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
+ SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
+ SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
+ operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
+ ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
+ SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
+ LDKSpendableOutputDescriptor* operator &() { return &self; }
+ LDKSpendableOutputDescriptor* operator ->() { return &self; }
+ const LDKSpendableOutputDescriptor* operator &() const { return &self; }
+ const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
+};
+class ChannelDerivationParameters {
+private:
+ LDKChannelDerivationParameters self;
+public:
+ ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
+ ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
+ ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
+ operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
+ ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
+ ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
+ LDKChannelDerivationParameters* operator &() { return &self; }
+ LDKChannelDerivationParameters* operator ->() { return &self; }
+ const LDKChannelDerivationParameters* operator &() const { return &self; }
+ const LDKChannelDerivationParameters* operator ->() const { return &self; }
+};
+class HTLCDescriptor {
+private:
+ LDKHTLCDescriptor self;
+public:
+ HTLCDescriptor(const HTLCDescriptor&) = delete;
+ HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
+ HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
+ operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
+ ~HTLCDescriptor() { HTLCDescriptor_free(self); }
+ HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
+ LDKHTLCDescriptor* operator &() { return &self; }
+ LDKHTLCDescriptor* operator ->() { return &self; }
+ const LDKHTLCDescriptor* operator &() const { return &self; }
+ const LDKHTLCDescriptor* operator ->() const { return &self; }
+};
+class ChannelSigner {
+private:
+ LDKChannelSigner self;
+public:
+ ChannelSigner(const ChannelSigner&) = delete;
+ ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
+ ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
+ operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
+ ~ChannelSigner() { ChannelSigner_free(self); }
+ ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
+ LDKChannelSigner* operator &() { return &self; }
+ LDKChannelSigner* operator ->() { return &self; }
+ const LDKChannelSigner* operator &() const { return &self; }
+ const LDKChannelSigner* operator ->() const { return &self; }
+ /**
+ * Gets the per-commitment point for a specific commitment number
+ *
+ * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
+ *
+ * If the signer returns `Err`, then the user is responsible for either force-closing the channel
+ * or calling `ChannelManager::signer_unblocked` (this method is only available when the
+ * `async_signing` cfg flag is enabled) once the signature is ready.
+ *
+ */
+ inline LDK::CResult_PublicKeyNoneZ get_per_commitment_point(uint64_t idx);
+ /**
+ * Gets the commitment secret for a specific commitment number as part of the revocation process
+ *
+ * An external signer implementation should error here if the commitment was already signed
+ * and should refuse to sign it in the future.
+ *
+ * May be called more than once for the same index.
+ *
+ * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
+ */
+ inline LDK::CResult__u832NoneZ release_commitment_secret(uint64_t idx);
+ /**
+ * Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
+ *
+ * This is required in order for the signer to make sure that releasing a commitment
+ * secret won't leave us without a broadcastable holder transaction.
+ * Policy checks should be implemented in this function, including checking the amount
+ * sent to us and checking the HTLCs.
+ *
+ * The preimages of outbound HTLCs that were fulfilled since the last commitment are provided.
+ * A validating signer should ensure that an HTLC output is removed only when the matching
+ * preimage is provided, or when the value to holder is restored.
+ *
+ * Note that all the relevant preimages will be provided, but there may also be additional
+ * irrelevant or duplicate preimages.
+ */
+ inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
+ /**
+ * Validate the counterparty's revocation.
+ *
+ * This is required in order for the signer to make sure that the state has moved
+ * forward and it is safe to sign the next counterparty commitment.
+ */
+ inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
+ /**
+ * Returns an arbitrary identifier describing the set of keys which are provided back to you in
+ * some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
+ * [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
+ */
+ inline LDKThirtyTwoBytes channel_keys_id();
+ /**
+ * Set the counterparty static channel data, including basepoints,
+ * `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
+ *
+ * This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
+ * instance, LDK will call this method exactly once - either immediately after construction
+ * (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
+ * information has been generated.
+ *
+ * channel_parameters.is_populated() MUST be true.
+ */
+ inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+};
+class Recipient {
+private:
+ LDKRecipient self;
+public:
+ Recipient(const Recipient&) = delete;
+ Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
+ Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
+ operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
+ Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
+ LDKRecipient* operator &() { return &self; }
+ LDKRecipient* operator ->() { return &self; }
+ const LDKRecipient* operator &() const { return &self; }
+ const LDKRecipient* operator ->() const { return &self; }
+};
+class EntropySource {
+private:
+ LDKEntropySource self;
+public:
+ EntropySource(const EntropySource&) = delete;
+ EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
+ EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
+ operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
+ ~EntropySource() { EntropySource_free(self); }
+ EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
+ LDKEntropySource* operator &() { return &self; }
+ LDKEntropySource* operator ->() { return &self; }
+ const LDKEntropySource* operator &() const { return &self; }
+ const LDKEntropySource* operator ->() const { return &self; }
+ /**
+ * Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
+ * different value each time it is called.
+ */
+ inline LDKThirtyTwoBytes get_secure_random_bytes();
+};
+class NodeSigner {
+private:
+ LDKNodeSigner self;
+public:
+ NodeSigner(const NodeSigner&) = delete;
+ NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
+ NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
+ operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
+ ~NodeSigner() { NodeSigner_free(self); }
+ NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
+ LDKNodeSigner* operator &() { return &self; }
+ LDKNodeSigner* operator ->() { return &self; }
+ const LDKNodeSigner* operator &() const { return &self; }
+ const LDKNodeSigner* operator ->() const { return &self; }
+ /**
+ * Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
+ *
+ * If the implementor of this trait supports [phantom node payments], then every node that is
+ * intended to be included in the phantom invoice route hints must return the same value from
+ * this method.
+ *
+ * This method must return the same value each time it is called.
+ *
+ * [phantom node payments]: PhantomKeysManager
+ */
+ inline LDKThirtyTwoBytes get_inbound_payment_key_material();
+ /**
+ * Get node id based on the provided [`Recipient`].
+ *
+ * This method must return the same value each time it is called with a given [`Recipient`]
+ * parameter.
+ *
+ * Errors if the [`Recipient`] variant is not supported by the implementation.
+ */
+ inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
+ /**
+ * Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
+ * one is provided. Note that this tweak can be applied to `other_key` instead of our node
+ * secret, though this is less efficient.
+ *
+ * Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
+ * should be resolved to allow LDK to resume forwarding HTLCs.
+ *
+ * Errors if the [`Recipient`] variant is not supported by the implementation.
+ */
+ inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
+ /**
+ * Sign an invoice.
+ *
+ * By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
+ * this trait to parse the invoice and make sure they're signing what they expect, rather than
+ * blindly signing the hash.
+ *
+ * The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
+ *
+ * The secret key used to sign the invoice is dependent on the [`Recipient`].
+ *
+ * Errors if the [`Recipient`] variant is not supported by the implementation.
+ */
+ inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(const struct LDKRawBolt11Invoice *NONNULL_PTR invoice, enum LDKRecipient recipient);
+ /**
+ * Signs the [`TaggedHash`] of a BOLT 12 invoice request.
+ *
+ * May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
+ * `invoice_request` is the callee.
+ *
+ * Implementors may check that the `invoice_request` is expected rather than blindly signing
+ * the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
+ * the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
+ * [`UnsignedInvoiceRequest::payer_id`].
+ *
+ * [`TaggedHash`]: crate::offers::merkle::TaggedHash
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
+ /**
+ * Signs the [`TaggedHash`] of a BOLT 12 invoice.
+ *
+ * May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
+ * callee.
+ *
+ * Implementors may check that the `invoice` is expected rather than blindly signing the tagged
+ * hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
+ * key or an ephemeral key to preserve privacy, whichever is associated with
+ * [`UnsignedBolt12Invoice::signing_pubkey`].
+ *
+ * [`TaggedHash`]: crate::offers::merkle::TaggedHash
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
+ /**
+ * Sign a gossip message.
+ *
+ * Note that if this fails, LDK may panic and the message will not be broadcast to the network
+ * or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
+ * message to be broadcast, as otherwise it may prevent one from receiving funds over the
+ * corresponding channel.
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
+};
+class OutputSpender {
+private:
+ LDKOutputSpender self;
+public:
+ OutputSpender(const OutputSpender&) = delete;
+ OutputSpender(OutputSpender&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpender)); }
+ OutputSpender(LDKOutputSpender&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpender)); }
+ operator LDKOutputSpender() && { LDKOutputSpender res = self; memset(&self, 0, sizeof(LDKOutputSpender)); return res; }
+ ~OutputSpender() { OutputSpender_free(self); }
+ OutputSpender& operator=(OutputSpender&& o) { OutputSpender_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpender)); return *this; }
+ LDKOutputSpender* operator &() { return &self; }
+ LDKOutputSpender* operator ->() { return &self; }
+ const LDKOutputSpender* operator &() const { return &self; }
+ const LDKOutputSpender* operator ->() const { return &self; }
+ /**
+ * Creates a [`Transaction`] which spends the given descriptors to the given outputs, plus an
+ * output to the given change destination (if sufficient change value remains). The
+ * transaction will have a feerate, at least, of the given value.
+ *
+ * The `locktime` argument is used to set the transaction's locktime. If `None`, the
+ * transaction will have a locktime of 0. It it recommended to set this to the current block
+ * height to avoid fee sniping, unless you have some specific reason to use a different
+ * locktime.
+ *
+ * Returns `Err(())` if the output value is greater than the input value minus required fee,
+ * if a descriptor was duplicated, or if an output descriptor `script_pubkey`
+ * does not match the one we can spend.
+ */
+ inline LDK::CResult_TransactionNoneZ spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
+};
+class SignerProvider {
+private:
+ LDKSignerProvider self;
+public:
+ SignerProvider(const SignerProvider&) = delete;
+ SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
+ SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
+ operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
+ ~SignerProvider() { SignerProvider_free(self); }
+ SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
+ LDKSignerProvider* operator &() { return &self; }
+ LDKSignerProvider* operator ->() { return &self; }
+ const LDKSignerProvider* operator &() const { return &self; }
+ const LDKSignerProvider* operator ->() const { return &self; }
+ /**
+ * Generates a unique `channel_keys_id` that can be used to obtain a [`Self::EcdsaSigner`] through
+ * [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
+ * implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
+ * `channel_keys_id`.
+ *
+ * This method must return a different value each time it is called.
+ */
+ inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
+ /**
+ * Derives the private key material backing a `Signer`.
+ *
+ * To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
+ * [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
+ * re-derived from its `channel_keys_id`, which can be obtained through its trait method
+ * [`ChannelSigner::channel_keys_id`].
+ */
+ inline LDK::EcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
+ /**
+ * Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
+ * This is only called during deserialization of other objects which contain
+ * [`EcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
+ * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
+ * contain no versioning scheme. You may wish to include your own version prefix and ensure
+ * you've read all of the provided bytes to ensure no corruption occurred.
+ *
+ * This method is slowly being phased out -- it will only be called when reading objects
+ * written by LDK versions prior to 0.0.113.
+ *
+ * [`Signer`]: Self::EcdsaSigner
+ * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ */
+ inline LDK::CResult_EcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
+ /**
+ * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
+ *
+ * If this function returns an error, this will result in a channel failing to open.
+ *
+ * This method should return a different value each time it is called, to avoid linking
+ * on-chain funds across channels as controlled to the same user. `channel_keys_id` may be
+ * used to derive a unique value for each channel.
+ */
+ inline LDK::CResult_CVec_u8ZNoneZ get_destination_script(struct LDKThirtyTwoBytes channel_keys_id);
+ /**
+ * Get a script pubkey which we will send funds to when closing a channel.
+ *
+ * If this function returns an error, this will result in a channel failing to open or close.
+ * In the event of a failure when the counterparty is initiating a close, this can result in a
+ * channel force close.
+ *
+ * This method should return a different value each time it is called, to avoid linking
+ * on-chain funds across channels as controlled to the same user.
+ */
+ inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
+};
+class ChangeDestinationSource {
+private:
+ LDKChangeDestinationSource self;
+public:
+ ChangeDestinationSource(const ChangeDestinationSource&) = delete;
+ ChangeDestinationSource(ChangeDestinationSource&& o) : self(o.self) { memset(&o, 0, sizeof(ChangeDestinationSource)); }
+ ChangeDestinationSource(LDKChangeDestinationSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChangeDestinationSource)); }
+ operator LDKChangeDestinationSource() && { LDKChangeDestinationSource res = self; memset(&self, 0, sizeof(LDKChangeDestinationSource)); return res; }
+ ~ChangeDestinationSource() { ChangeDestinationSource_free(self); }
+ ChangeDestinationSource& operator=(ChangeDestinationSource&& o) { ChangeDestinationSource_free(self); self = o.self; memset(&o, 0, sizeof(ChangeDestinationSource)); return *this; }
+ LDKChangeDestinationSource* operator &() { return &self; }
+ LDKChangeDestinationSource* operator ->() { return &self; }
+ const LDKChangeDestinationSource* operator &() const { return &self; }
+ const LDKChangeDestinationSource* operator ->() const { return &self; }
+ /**
+ * Returns a script pubkey which can be used as a change destination for
+ * [`OutputSpender::spend_spendable_outputs`].
+ *
+ * This method should return a different value each time it is called, to avoid linking
+ * on-chain funds controlled to the same user.
+ */
+ inline LDK::CResult_CVec_u8ZNoneZ get_change_destination_script();
+};
+class InMemorySigner {
+private:
+ LDKInMemorySigner self;
+public:
+ InMemorySigner(const InMemorySigner&) = delete;
+ InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
+ InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
+ operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
+ ~InMemorySigner() { InMemorySigner_free(self); }
+ InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
+ LDKInMemorySigner* operator &() { return &self; }
+ LDKInMemorySigner* operator ->() { return &self; }
+ const LDKInMemorySigner* operator &() const { return &self; }
+ const LDKInMemorySigner* operator ->() const { return &self; }
+};
+class KeysManager {
+private:
+ LDKKeysManager self;
+public:
+ KeysManager(const KeysManager&) = delete;
+ KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
+ KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
+ operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
+ ~KeysManager() { KeysManager_free(self); }
+ KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
+ LDKKeysManager* operator &() { return &self; }
+ LDKKeysManager* operator ->() { return &self; }
+ const LDKKeysManager* operator &() const { return &self; }
+ const LDKKeysManager* operator ->() const { return &self; }
+};
+class PhantomKeysManager {
+private:
+ LDKPhantomKeysManager self;
+public:
+ PhantomKeysManager(const PhantomKeysManager&) = delete;
+ PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
+ PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
+ operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
+ ~PhantomKeysManager() { PhantomKeysManager_free(self); }
+ PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
+ LDKPhantomKeysManager* operator &() { return &self; }
+ LDKPhantomKeysManager* operator ->() { return &self; }
+ const LDKPhantomKeysManager* operator &() const { return &self; }
+ const LDKPhantomKeysManager* operator ->() const { return &self; }
+};
+class RandomBytes {
+private:
+ LDKRandomBytes self;
+public:
+ RandomBytes(const RandomBytes&) = delete;
+ RandomBytes(RandomBytes&& o) : self(o.self) { memset(&o, 0, sizeof(RandomBytes)); }
+ RandomBytes(LDKRandomBytes&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRandomBytes)); }
+ operator LDKRandomBytes() && { LDKRandomBytes res = self; memset(&self, 0, sizeof(LDKRandomBytes)); return res; }
+ ~RandomBytes() { RandomBytes_free(self); }
+ RandomBytes& operator=(RandomBytes&& o) { RandomBytes_free(self); self = o.self; memset(&o, 0, sizeof(RandomBytes)); return *this; }
+ LDKRandomBytes* operator &() { return &self; }
+ LDKRandomBytes* operator ->() { return &self; }
+ const LDKRandomBytes* operator &() const { return &self; }
+ const LDKRandomBytes* operator ->() const { return &self; }
+};
+class BackgroundProcessor {
+private:
+ LDKBackgroundProcessor self;
+public:
+ BackgroundProcessor(const BackgroundProcessor&) = delete;
+ BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
+ BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
+ operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
+ ~BackgroundProcessor() { BackgroundProcessor_free(self); }
+ BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
+ LDKBackgroundProcessor* operator &() { return &self; }
+ LDKBackgroundProcessor* operator ->() { return &self; }
+ const LDKBackgroundProcessor* operator &() const { return &self; }
+ const LDKBackgroundProcessor* operator ->() const { return &self; }
+};
+class GossipSync {
+private:
+ LDKGossipSync self;
+public:
+ GossipSync(const GossipSync&) = delete;
+ GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
+ GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
+ operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
+ ~GossipSync() { GossipSync_free(self); }
+ GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
+ LDKGossipSync* operator &() { return &self; }
+ LDKGossipSync* operator ->() { return &self; }
+ const LDKGossipSync* operator &() const { return &self; }
+ const LDKGossipSync* operator ->() const { return &self; }
+};
+class DefaultRouter {
+private:
+ LDKDefaultRouter self;
+public:
+ DefaultRouter(const DefaultRouter&) = delete;
+ DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
+ DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
+ operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
+ ~DefaultRouter() { DefaultRouter_free(self); }
+ DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
+ LDKDefaultRouter* operator &() { return &self; }
+ LDKDefaultRouter* operator ->() { return &self; }
+ const LDKDefaultRouter* operator &() const { return &self; }
+ const LDKDefaultRouter* operator ->() const { return &self; }
+};
+class Router {
+private:
+ LDKRouter self;
+public:
+ Router(const Router&) = delete;
+ Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
+ Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
+ operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
+ ~Router() { Router_free(self); }
+ Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
+ LDKRouter* operator &() { return &self; }
+ LDKRouter* operator ->() { return &self; }
+ const LDKRouter* operator &() const { return &self; }
+ const LDKRouter* operator ->() const { return &self; }
+ /**
+ * Finds a [`Route`] for a payment between the given `payer` and a payee.
+ *
+ * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
+ * and [`RouteParameters::final_value_msat`], respectively.
+ *
+ * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs);
+ /**
+ * Finds a [`Route`] for a payment between the given `payer` and a payee.
+ *
+ * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
+ * and [`RouteParameters::final_value_msat`], respectively.
+ *
+ * Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
+ * payment.
+ *
+ * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::CResult_RouteLightningErrorZ find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id);
+ /**
+ * Creates [`BlindedPaymentPath`]s for payment to the `recipient` node. The channels in `first_hops`
+ * are assumed to be with the `recipient`'s peers. The payment secret and any constraints are
+ * given in `tlvs`.
+ */
+ inline LDK::CResult_CVec_BlindedPaymentPathZNoneZ create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats);
+};
+class ScorerAccountingForInFlightHtlcs {
+private:
+ LDKScorerAccountingForInFlightHtlcs self;
+public:
+ ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
+ ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
+ ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
+ operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
+ ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
+ ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
+ LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
+ LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
+ const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
+ const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
+};
+class InFlightHtlcs {
+private:
+ LDKInFlightHtlcs self;
+public:
+ InFlightHtlcs(const InFlightHtlcs&) = delete;
+ InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
+ InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
+ operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
+ ~InFlightHtlcs() { InFlightHtlcs_free(self); }
+ InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
+ LDKInFlightHtlcs* operator &() { return &self; }
+ LDKInFlightHtlcs* operator ->() { return &self; }
+ const LDKInFlightHtlcs* operator &() const { return &self; }
+ const LDKInFlightHtlcs* operator ->() const { return &self; }
+};
+class RouteHop {
+private:
+ LDKRouteHop self;
+public:
+ RouteHop(const RouteHop&) = delete;
+ RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
+ RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
+ operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
+ ~RouteHop() { RouteHop_free(self); }
+ RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
+ LDKRouteHop* operator &() { return &self; }
+ LDKRouteHop* operator ->() { return &self; }
+ const LDKRouteHop* operator &() const { return &self; }
+ const LDKRouteHop* operator ->() const { return &self; }
+};
+class BlindedTail {
+private:
+ LDKBlindedTail self;
+public:
+ BlindedTail(const BlindedTail&) = delete;
+ BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
+ BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
+ operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
+ ~BlindedTail() { BlindedTail_free(self); }
+ BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
+ LDKBlindedTail* operator &() { return &self; }
+ LDKBlindedTail* operator ->() { return &self; }
+ const LDKBlindedTail* operator &() const { return &self; }
+ const LDKBlindedTail* operator ->() const { return &self; }
+};
+class Path {
+private:
+ LDKPath self;
+public:
+ Path(const Path&) = delete;
+ Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
+ Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
+ operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
+ ~Path() { Path_free(self); }
+ Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
+ LDKPath* operator &() { return &self; }
+ LDKPath* operator ->() { return &self; }
+ const LDKPath* operator &() const { return &self; }
+ const LDKPath* operator ->() const { return &self; }
+};
+class Route {
+private:
+ LDKRoute self;
+public:
+ Route(const Route&) = delete;
+ Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
+ Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
+ operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
+ ~Route() { Route_free(self); }
+ Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
+ LDKRoute* operator &() { return &self; }
+ LDKRoute* operator ->() { return &self; }
+ const LDKRoute* operator &() const { return &self; }
+ const LDKRoute* operator ->() const { return &self; }
+};
+class RouteParameters {
+private:
+ LDKRouteParameters self;
+public:
+ RouteParameters(const RouteParameters&) = delete;
+ RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
+ RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
+ operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
+ ~RouteParameters() { RouteParameters_free(self); }
+ RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
+ LDKRouteParameters* operator &() { return &self; }
+ LDKRouteParameters* operator ->() { return &self; }
+ const LDKRouteParameters* operator &() const { return &self; }
+ const LDKRouteParameters* operator ->() const { return &self; }
+};
+class PaymentParameters {
+private:
+ LDKPaymentParameters self;
+public:
+ PaymentParameters(const PaymentParameters&) = delete;
+ PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
+ PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
+ operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
+ ~PaymentParameters() { PaymentParameters_free(self); }
+ PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
+ LDKPaymentParameters* operator &() { return &self; }
+ LDKPaymentParameters* operator ->() { return &self; }
+ const LDKPaymentParameters* operator &() const { return &self; }
+ const LDKPaymentParameters* operator ->() const { return &self; }
+};
+class Payee {
+private:
+ LDKPayee self;
+public:
+ Payee(const Payee&) = delete;
+ Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
+ Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
+ operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
+ ~Payee() { Payee_free(self); }
+ Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
+ LDKPayee* operator &() { return &self; }
+ LDKPayee* operator ->() { return &self; }
+ const LDKPayee* operator &() const { return &self; }
+ const LDKPayee* operator ->() const { return &self; }
+};
+class FirstHopCandidate {
+private:
+ LDKFirstHopCandidate self;
+public:
+ FirstHopCandidate(const FirstHopCandidate&) = delete;
+ FirstHopCandidate(FirstHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(FirstHopCandidate)); }
+ FirstHopCandidate(LDKFirstHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFirstHopCandidate)); }
+ operator LDKFirstHopCandidate() && { LDKFirstHopCandidate res = self; memset(&self, 0, sizeof(LDKFirstHopCandidate)); return res; }
+ ~FirstHopCandidate() { FirstHopCandidate_free(self); }
+ FirstHopCandidate& operator=(FirstHopCandidate&& o) { FirstHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(FirstHopCandidate)); return *this; }
+ LDKFirstHopCandidate* operator &() { return &self; }
+ LDKFirstHopCandidate* operator ->() { return &self; }
+ const LDKFirstHopCandidate* operator &() const { return &self; }
+ const LDKFirstHopCandidate* operator ->() const { return &self; }
+};
+class PublicHopCandidate {
+private:
+ LDKPublicHopCandidate self;
+public:
+ PublicHopCandidate(const PublicHopCandidate&) = delete;
+ PublicHopCandidate(PublicHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PublicHopCandidate)); }
+ PublicHopCandidate(LDKPublicHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPublicHopCandidate)); }
+ operator LDKPublicHopCandidate() && { LDKPublicHopCandidate res = self; memset(&self, 0, sizeof(LDKPublicHopCandidate)); return res; }
+ ~PublicHopCandidate() { PublicHopCandidate_free(self); }
+ PublicHopCandidate& operator=(PublicHopCandidate&& o) { PublicHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PublicHopCandidate)); return *this; }
+ LDKPublicHopCandidate* operator &() { return &self; }
+ LDKPublicHopCandidate* operator ->() { return &self; }
+ const LDKPublicHopCandidate* operator &() const { return &self; }
+ const LDKPublicHopCandidate* operator ->() const { return &self; }
+};
+class PrivateHopCandidate {
+private:
+ LDKPrivateHopCandidate self;
+public:
+ PrivateHopCandidate(const PrivateHopCandidate&) = delete;
+ PrivateHopCandidate(PrivateHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateHopCandidate)); }
+ PrivateHopCandidate(LDKPrivateHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateHopCandidate)); }
+ operator LDKPrivateHopCandidate() && { LDKPrivateHopCandidate res = self; memset(&self, 0, sizeof(LDKPrivateHopCandidate)); return res; }
+ ~PrivateHopCandidate() { PrivateHopCandidate_free(self); }
+ PrivateHopCandidate& operator=(PrivateHopCandidate&& o) { PrivateHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PrivateHopCandidate)); return *this; }
+ LDKPrivateHopCandidate* operator &() { return &self; }
+ LDKPrivateHopCandidate* operator ->() { return &self; }
+ const LDKPrivateHopCandidate* operator &() const { return &self; }
+ const LDKPrivateHopCandidate* operator ->() const { return &self; }
+};
+class BlindedPathCandidate {
+private:
+ LDKBlindedPathCandidate self;
+public:
+ BlindedPathCandidate(const BlindedPathCandidate&) = delete;
+ BlindedPathCandidate(BlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPathCandidate)); }
+ BlindedPathCandidate(LDKBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPathCandidate)); }
+ operator LDKBlindedPathCandidate() && { LDKBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKBlindedPathCandidate)); return res; }
+ ~BlindedPathCandidate() { BlindedPathCandidate_free(self); }
+ BlindedPathCandidate& operator=(BlindedPathCandidate&& o) { BlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPathCandidate)); return *this; }
+ LDKBlindedPathCandidate* operator &() { return &self; }
+ LDKBlindedPathCandidate* operator ->() { return &self; }
+ const LDKBlindedPathCandidate* operator &() const { return &self; }
+ const LDKBlindedPathCandidate* operator ->() const { return &self; }
+};
+class OneHopBlindedPathCandidate {
+private:
+ LDKOneHopBlindedPathCandidate self;
+public:
+ OneHopBlindedPathCandidate(const OneHopBlindedPathCandidate&) = delete;
+ OneHopBlindedPathCandidate(OneHopBlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); }
+ OneHopBlindedPathCandidate(LDKOneHopBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOneHopBlindedPathCandidate)); }
+ operator LDKOneHopBlindedPathCandidate() && { LDKOneHopBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKOneHopBlindedPathCandidate)); return res; }
+ ~OneHopBlindedPathCandidate() { OneHopBlindedPathCandidate_free(self); }
+ OneHopBlindedPathCandidate& operator=(OneHopBlindedPathCandidate&& o) { OneHopBlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); return *this; }
+ LDKOneHopBlindedPathCandidate* operator &() { return &self; }
+ LDKOneHopBlindedPathCandidate* operator ->() { return &self; }
+ const LDKOneHopBlindedPathCandidate* operator &() const { return &self; }
+ const LDKOneHopBlindedPathCandidate* operator ->() const { return &self; }
+};
+class CandidateRouteHop {
+private:
+ LDKCandidateRouteHop self;
+public:
+ CandidateRouteHop(const CandidateRouteHop&) = delete;
+ CandidateRouteHop(CandidateRouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(CandidateRouteHop)); }
+ CandidateRouteHop(LDKCandidateRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCandidateRouteHop)); }
+ operator LDKCandidateRouteHop() && { LDKCandidateRouteHop res = self; memset(&self, 0, sizeof(LDKCandidateRouteHop)); return res; }
+ ~CandidateRouteHop() { CandidateRouteHop_free(self); }
+ CandidateRouteHop& operator=(CandidateRouteHop&& o) { CandidateRouteHop_free(self); self = o.self; memset(&o, 0, sizeof(CandidateRouteHop)); return *this; }
+ LDKCandidateRouteHop* operator &() { return &self; }
+ LDKCandidateRouteHop* operator ->() { return &self; }
+ const LDKCandidateRouteHop* operator &() const { return &self; }
+ const LDKCandidateRouteHop* operator ->() const { return &self; }
+};
+class UntrustedString {
+private:
+ LDKUntrustedString self;
+public:
+ UntrustedString(const UntrustedString&) = delete;
+ UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
+ UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
+ operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
+ ~UntrustedString() { UntrustedString_free(self); }
+ UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
+ LDKUntrustedString* operator &() { return &self; }
+ LDKUntrustedString* operator ->() { return &self; }
+ const LDKUntrustedString* operator &() const { return &self; }
+ const LDKUntrustedString* operator ->() const { return &self; }
+};
+class PrintableString {
+private:
+ LDKPrintableString self;
+public:
+ PrintableString(const PrintableString&) = delete;
+ PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
+ PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
+ operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
+ ~PrintableString() { PrintableString_free(self); }
+ PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
+ LDKPrintableString* operator &() { return &self; }
+ LDKPrintableString* operator ->() { return &self; }
+ const LDKPrintableString* operator &() const { return &self; }
+ const LDKPrintableString* operator ->() const { return &self; }
+};
+class ScoreLookUp {
+private:
+ LDKScoreLookUp self;
+public:
+ ScoreLookUp(const ScoreLookUp&) = delete;
+ ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
+ ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
+ operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
+ ~ScoreLookUp() { ScoreLookUp_free(self); }
+ ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
+ LDKScoreLookUp* operator &() { return &self; }
+ LDKScoreLookUp* operator ->() { return &self; }
+ const LDKScoreLookUp* operator &() const { return &self; }
+ const LDKScoreLookUp* operator ->() const { return &self; }
+ /**
+ * Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
+ * given channel in the direction from `source` to `target`.
+ *
+ * The channel's capacity (less any other MPP parts that are also being considered for use in
+ * the same payment) is given by `capacity_msat`. It may be determined from various sources
+ * such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
+ * [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
+ * Thus, implementations should be overflow-safe.
+ */
+ inline uint64_t channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
+};
+class ScoreUpdate {
+private:
+ LDKScoreUpdate self;
+public:
+ ScoreUpdate(const ScoreUpdate&) = delete;
+ ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
+ ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
+ operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
+ ~ScoreUpdate() { ScoreUpdate_free(self); }
+ ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
+ LDKScoreUpdate* operator &() { return &self; }
+ LDKScoreUpdate* operator ->() { return &self; }
+ const LDKScoreUpdate* operator &() const { return &self; }
+ const LDKScoreUpdate* operator ->() const { return &self; }
+ /**
+ * Handles updating channel penalties after failing to route through a channel.
+ */
+ inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
+ /**
+ * Handles updating channel penalties after successfully routing along a path.
+ */
+ inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
+ /**
+ * Handles updating channel penalties after a probe over the given path failed.
+ */
+ inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
+ /**
+ * Handles updating channel penalties after a probe over the given path succeeded.
+ */
+ inline void probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
+ /**
+ * Scorers may wish to reduce their certainty of channel liquidity information over time.
+ * Thus, this method is provided to allow scorers to observe the passage of time - the holder
+ * of this object should call this method regularly (generally via the
+ * `lightning-background-processor` crate).
+ */
+ inline void time_passed(uint64_t duration_since_epoch);
+};
+class Score {
+private:
+ LDKScore self;
+public:
+ Score(const Score&) = delete;
+ Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
+ Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
+ operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
+ ~Score() { Score_free(self); }
+ Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
+ LDKScore* operator &() { return &self; }
+ LDKScore* operator ->() { return &self; }
+ const LDKScore* operator &() const { return &self; }
+ const LDKScore* operator ->() const { return &self; }
+};
+class LockableScore {
+private:
+ LDKLockableScore self;
+public:
+ LockableScore(const LockableScore&) = delete;
+ LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
+ LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
+ operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
+ ~LockableScore() { LockableScore_free(self); }
+ LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
+ LDKLockableScore* operator &() { return &self; }
+ LDKLockableScore* operator ->() { return &self; }
+ const LDKLockableScore* operator &() const { return &self; }
+ const LDKLockableScore* operator ->() const { return &self; }
+ /**
+ * Returns read locked scorer.
+ */
+ inline LDK::ScoreLookUp read_lock();
+ /**
+ * Returns write locked scorer.
+ */
+ inline LDK::ScoreUpdate write_lock();
+};
+class WriteableScore {
+private:
+ LDKWriteableScore self;
+public:
+ WriteableScore(const WriteableScore&) = delete;
+ WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
+ WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
+ operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
+ ~WriteableScore() { WriteableScore_free(self); }
+ WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
+ LDKWriteableScore* operator &() { return &self; }
+ LDKWriteableScore* operator ->() { return &self; }
+ const LDKWriteableScore* operator &() const { return &self; }
+ const LDKWriteableScore* operator ->() const { return &self; }
+};
+class MultiThreadedLockableScore {
+private:
+ LDKMultiThreadedLockableScore self;
+public:
+ MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
+ MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
+ MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
+ operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
+ ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
+ MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
+ LDKMultiThreadedLockableScore* operator &() { return &self; }
+ LDKMultiThreadedLockableScore* operator ->() { return &self; }
+ const LDKMultiThreadedLockableScore* operator &() const { return &self; }
+ const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
+};
+class MultiThreadedScoreLockRead {
+private:
+ LDKMultiThreadedScoreLockRead self;
+public:
+ MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
+ MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
+ MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
+ operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
+ ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
+ MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
+ LDKMultiThreadedScoreLockRead* operator &() { return &self; }
+ LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
+ const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
+ const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
+};
+class MultiThreadedScoreLockWrite {
+private:
+ LDKMultiThreadedScoreLockWrite self;
+public:
+ MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
+ MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
+ MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
+ operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
+ ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
+ MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
+ LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
+ LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
+ const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
+ const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
+};
+class ChannelUsage {
+private:
+ LDKChannelUsage self;
+public:
+ ChannelUsage(const ChannelUsage&) = delete;
+ ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
+ ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
+ operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
+ ~ChannelUsage() { ChannelUsage_free(self); }
+ ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
+ LDKChannelUsage* operator &() { return &self; }
+ LDKChannelUsage* operator ->() { return &self; }
+ const LDKChannelUsage* operator &() const { return &self; }
+ const LDKChannelUsage* operator ->() const { return &self; }
+};
+class FixedPenaltyScorer {
+private:
+ LDKFixedPenaltyScorer self;
+public:
+ FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
+ FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
+ FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
+ operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
+ ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
+ FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
+ LDKFixedPenaltyScorer* operator &() { return &self; }
+ LDKFixedPenaltyScorer* operator ->() { return &self; }
+ const LDKFixedPenaltyScorer* operator &() const { return &self; }
+ const LDKFixedPenaltyScorer* operator ->() const { return &self; }
+};
+class ProbabilisticScorer {
+private:
+ LDKProbabilisticScorer self;
+public:
+ ProbabilisticScorer(const ProbabilisticScorer&) = delete;
+ ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
+ ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
+ operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
+ ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
+ ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
+ LDKProbabilisticScorer* operator &() { return &self; }
+ LDKProbabilisticScorer* operator ->() { return &self; }
+ const LDKProbabilisticScorer* operator &() const { return &self; }
+ const LDKProbabilisticScorer* operator ->() const { return &self; }
+};
+class ProbabilisticScoringFeeParameters {
+private:
+ LDKProbabilisticScoringFeeParameters self;
+public:
+ ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
+ ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
+ ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
+ operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
+ ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
+ ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
+ LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
+ LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
+ const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
+ const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
+};
+class ProbabilisticScoringDecayParameters {
+private:
+ LDKProbabilisticScoringDecayParameters self;
+public:
+ ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
+ ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
+ ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
+ operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
+ ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
+ ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
+ LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
+ LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
+ const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
+ const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
+};
+class BestBlock {
+private:
+ LDKBestBlock self;
+public:
+ BestBlock(const BestBlock&) = delete;
+ BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
+ BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
+ operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
+ ~BestBlock() { BestBlock_free(self); }
+ BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
+ LDKBestBlock* operator &() { return &self; }
+ LDKBestBlock* operator ->() { return &self; }
+ const LDKBestBlock* operator &() const { return &self; }
+ const LDKBestBlock* operator ->() const { return &self; }
+};
+class Listen {
+private:
+ LDKListen self;
+public:
+ Listen(const Listen&) = delete;
+ Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
+ Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
+ operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
+ ~Listen() { Listen_free(self); }
+ Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
+ LDKListen* operator &() { return &self; }
+ LDKListen* operator ->() { return &self; }
+ const LDKListen* operator &() const { return &self; }
+ const LDKListen* operator ->() const { return &self; }
+ /**
+ * Notifies the listener that a block was added at the given height, with the transaction data
+ * possibly filtered.
+ */
+ inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
+ /**
+ * Notifies the listener that a block was added at the given height.
+ */
+ inline void block_connected(struct LDKu8slice block, uint32_t height);
+ /**
+ * Notifies the listener that a block was removed at the given height.
+ */
+ inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
+};
+class Confirm {
+private:
+ LDKConfirm self;
+public:
+ Confirm(const Confirm&) = delete;
+ Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
+ Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
+ operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
+ ~Confirm() { Confirm_free(self); }
+ Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
+ LDKConfirm* operator &() { return &self; }
+ LDKConfirm* operator ->() { return &self; }
+ const LDKConfirm* operator &() const { return &self; }
+ const LDKConfirm* operator ->() const { return &self; }
+ /**
+ * Notifies LDK of transactions confirmed in a block with a given header and height.
+ *
+ * Must be called for any transactions registered by [`Filter::register_tx`] or any
+ * transactions spending an output registered by [`Filter::register_output`]. Such transactions
+ * appearing in the same block do not need to be included in the same call; instead, multiple
+ * calls with additional transactions may be made so long as they are made in [chain order].
+ *
+ * May be called before or after [`best_block_updated`] for the corresponding block. However,
+ * in the event of a chain reorganization, it must not be called with a `header` that is no
+ * longer in the chain as of the last call to [`best_block_updated`].
+ *
+ * [chain order]: Confirm#order
+ * [`best_block_updated`]: Self::best_block_updated
+ */
+ inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
+ /**
+ * Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
+ *
+ * Must be called for any transaction returned by [`get_relevant_txids`] if it has been
+ * reorganized out of the best chain or if it is no longer confirmed in the block with the
+ * given block hash. Once called, the given transaction will not be returned
+ * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
+ *
+ * [`get_relevant_txids`]: Self::get_relevant_txids
+ * [`transactions_confirmed`]: Self::transactions_confirmed
+ */
+ inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
+ /**
+ * Notifies LDK of an update to the best header connected at the given height.
+ *
+ * Must be called whenever a new chain tip becomes available. May be skipped for intermediary
+ * blocks.
+ */
+ inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
+ /**
+ * Returns transactions that must be monitored for reorganization out of the chain along
+ * with the height and the hash of the block as part of which it had been previously confirmed.
+ *
+ * Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
+ * 0.0.112 and prior, in which case you need to manually track previous confirmations.
+ *
+ * Will include any transactions passed to [`transactions_confirmed`] that have insufficient
+ * confirmations to be safe from a chain reorganization. Will not include any transactions
+ * passed to [`transaction_unconfirmed`], unless later reconfirmed.
+ *
+ * Must be called to determine the subset of transactions that must be monitored for
+ * reorganization. Will be idempotent between calls but may change as a result of calls to the
+ * other interface methods. Thus, this is useful to determine which transactions must be
+ * given to [`transaction_unconfirmed`].
+ *
+ * If any of the returned transactions are confirmed in a block other than the one with the
+ * given hash at the given height, they need to be unconfirmed and reconfirmed via
+ * [`transaction_unconfirmed`] and [`transactions_confirmed`], respectively.
+ *
+ * [`transactions_confirmed`]: Self::transactions_confirmed
+ * [`transaction_unconfirmed`]: Self::transaction_unconfirmed
+ */
+ inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ get_relevant_txids();
+};
+class ChannelMonitorUpdateStatus {
+private:
+ LDKChannelMonitorUpdateStatus self;
+public:
+ ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
+ ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
+ ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
+ operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
+ ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
+ LDKChannelMonitorUpdateStatus* operator &() { return &self; }
+ LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
+ const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
+ const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
+};
+class Watch {
+private:
+ LDKWatch self;
+public:
+ Watch(const Watch&) = delete;
+ Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
+ Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
+ operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
+ ~Watch() { Watch_free(self); }
+ Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
+ LDKWatch* operator &() { return &self; }
+ LDKWatch* operator ->() { return &self; }
+ const LDKWatch* operator &() const { return &self; }
+ const LDKWatch* operator ->() const { return &self; }
+ /**
+ * Watches a channel identified by `funding_txo` using `monitor`.
+ *
+ * Implementations are responsible for watching the chain for the funding transaction along
+ * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
+ * calling [`block_connected`] and [`block_disconnected`] on the monitor.
+ *
+ * A return of `Err(())` indicates that the channel should immediately be force-closed without
+ * broadcasting the funding transaction.
+ *
+ * If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
+ * must be returned.
+ *
+ * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
+ * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
+ * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
+ */
+ inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
+ /**
+ * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
+ *
+ * Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
+ * may fail (returning an `Err(())`), in which case this should return
+ * [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
+ * generally implies the channel has been closed (either by the funding outpoint being spent
+ * on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
+ * and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
+ *
+ * In general, persistence failures should be retried after returning
+ * [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
+ * cannot be retried, the node should shut down immediately after returning
+ * [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
+ *
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ */
+ inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
+ /**
+ * Returns any monitor events since the last call. Subsequent calls must only return new
+ * events.
+ *
+ * Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
+ * further events may be returned here until the [`ChannelMonitor`] has been fully persisted
+ * to disk.
+ *
+ * For details on asynchronous [`ChannelMonitor`] updating and returning
+ * [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
+ */
+ inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
+};
+class Filter {
+private:
+ LDKFilter self;
+public:
+ Filter(const Filter&) = delete;
+ Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
+ Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
+ operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
+ ~Filter() { Filter_free(self); }
+ Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
+ LDKFilter* operator &() { return &self; }
+ LDKFilter* operator ->() { return &self; }
+ const LDKFilter* operator &() const { return &self; }
+ const LDKFilter* operator ->() const { return &self; }
+ /**
+ * Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
+ * a spending condition.
+ *
+ * This may be used, for example, to monitor for when a funding transaction confirms.
+ *
+ * The `script_pubkey` is provided for informational purposes and may be useful for block
+ * sources which only support filtering on scripts.
+ */
+ inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
+ /**
+ * Registers interest in spends of a transaction output.
+ *
+ * Note that this method might be called during processing of a new block. You therefore need
+ * to ensure that also dependent output spents within an already connected block are correctly
+ * handled, e.g., by re-scanning the block in question whenever new outputs have been
+ * registered mid-processing.
+ *
+ * This may be used, for example, to monitor for when a funding output is spent (by any
+ * transaction).
+ */
+ inline void register_output(struct LDKWatchedOutput output);
+};
+class WatchedOutput {
+private:
+ LDKWatchedOutput self;
+public:
+ WatchedOutput(const WatchedOutput&) = delete;
+ WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
+ WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
+ operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
+ ~WatchedOutput() { WatchedOutput_free(self); }
+ WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
+ LDKWatchedOutput* operator &() { return &self; }
+ LDKWatchedOutput* operator ->() { return &self; }
+ const LDKWatchedOutput* operator &() const { return &self; }
+ const LDKWatchedOutput* operator ->() const { return &self; }
+};
+class OfferId {
+private:
+ LDKOfferId self;
+public:
+ OfferId(const OfferId&) = delete;
+ OfferId(OfferId&& o) : self(o.self) { memset(&o, 0, sizeof(OfferId)); }
+ OfferId(LDKOfferId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferId)); }
+ operator LDKOfferId() && { LDKOfferId res = self; memset(&self, 0, sizeof(LDKOfferId)); return res; }
+ ~OfferId() { OfferId_free(self); }
+ OfferId& operator=(OfferId&& o) { OfferId_free(self); self = o.self; memset(&o, 0, sizeof(OfferId)); return *this; }
+ LDKOfferId* operator &() { return &self; }
+ LDKOfferId* operator ->() { return &self; }
+ const LDKOfferId* operator &() const { return &self; }
+ const LDKOfferId* operator ->() const { return &self; }
+};
+class OfferWithExplicitMetadataBuilder {
+private:
+ LDKOfferWithExplicitMetadataBuilder self;
+public:
+ OfferWithExplicitMetadataBuilder(const OfferWithExplicitMetadataBuilder&) = delete;
+ OfferWithExplicitMetadataBuilder(OfferWithExplicitMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); }
+ OfferWithExplicitMetadataBuilder(LDKOfferWithExplicitMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); }
+ operator LDKOfferWithExplicitMetadataBuilder() && { LDKOfferWithExplicitMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); return res; }
+ ~OfferWithExplicitMetadataBuilder() { OfferWithExplicitMetadataBuilder_free(self); }
+ OfferWithExplicitMetadataBuilder& operator=(OfferWithExplicitMetadataBuilder&& o) { OfferWithExplicitMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); return *this; }
+ LDKOfferWithExplicitMetadataBuilder* operator &() { return &self; }
+ LDKOfferWithExplicitMetadataBuilder* operator ->() { return &self; }
+ const LDKOfferWithExplicitMetadataBuilder* operator &() const { return &self; }
+ const LDKOfferWithExplicitMetadataBuilder* operator ->() const { return &self; }
+};
+class OfferWithDerivedMetadataBuilder {
+private:
+ LDKOfferWithDerivedMetadataBuilder self;
+public:
+ OfferWithDerivedMetadataBuilder(const OfferWithDerivedMetadataBuilder&) = delete;
+ OfferWithDerivedMetadataBuilder(OfferWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); }
+ OfferWithDerivedMetadataBuilder(LDKOfferWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); }
+ operator LDKOfferWithDerivedMetadataBuilder() && { LDKOfferWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); return res; }
+ ~OfferWithDerivedMetadataBuilder() { OfferWithDerivedMetadataBuilder_free(self); }
+ OfferWithDerivedMetadataBuilder& operator=(OfferWithDerivedMetadataBuilder&& o) { OfferWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); return *this; }
+ LDKOfferWithDerivedMetadataBuilder* operator &() { return &self; }
+ LDKOfferWithDerivedMetadataBuilder* operator ->() { return &self; }
+ const LDKOfferWithDerivedMetadataBuilder* operator &() const { return &self; }
+ const LDKOfferWithDerivedMetadataBuilder* operator ->() const { return &self; }
+};
+class Offer {
+private:
+ LDKOffer self;
+public:
+ Offer(const Offer&) = delete;
+ Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
+ Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
+ operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
+ ~Offer() { Offer_free(self); }
+ Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
+ LDKOffer* operator &() { return &self; }
+ LDKOffer* operator ->() { return &self; }
+ const LDKOffer* operator &() const { return &self; }
+ const LDKOffer* operator ->() const { return &self; }
+};
+class Amount {
+private:
+ LDKAmount self;
+public:
+ Amount(const Amount&) = delete;
+ Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
+ Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
+ operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
+ ~Amount() { Amount_free(self); }
+ Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
+ LDKAmount* operator &() { return &self; }
+ LDKAmount* operator ->() { return &self; }
+ const LDKAmount* operator &() const { return &self; }
+ const LDKAmount* operator ->() const { return &self; }
+};
+class Quantity {
+private:
+ LDKQuantity self;
+public:
+ Quantity(const Quantity&) = delete;
+ Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
+ Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
+ operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
+ ~Quantity() { Quantity_free(self); }
+ Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
+ LDKQuantity* operator &() { return &self; }
+ LDKQuantity* operator ->() { return &self; }
+ const LDKQuantity* operator &() const { return &self; }
+ const LDKQuantity* operator ->() const { return &self; }
+};
+class NodeId {
+private:
+ LDKNodeId self;
+public:
+ NodeId(const NodeId&) = delete;
+ NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
+ NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
+ operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
+ ~NodeId() { NodeId_free(self); }
+ NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
+ LDKNodeId* operator &() { return &self; }
+ LDKNodeId* operator ->() { return &self; }
+ const LDKNodeId* operator &() const { return &self; }
+ const LDKNodeId* operator ->() const { return &self; }
+};
+class NetworkGraph {
+private:
+ LDKNetworkGraph self;
+public:
+ NetworkGraph(const NetworkGraph&) = delete;
+ NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
+ NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
+ operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
+ ~NetworkGraph() { NetworkGraph_free(self); }
+ NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
+ LDKNetworkGraph* operator &() { return &self; }
+ LDKNetworkGraph* operator ->() { return &self; }
+ const LDKNetworkGraph* operator &() const { return &self; }
+ const LDKNetworkGraph* operator ->() const { return &self; }
+};
+class ReadOnlyNetworkGraph {
+private:
+ LDKReadOnlyNetworkGraph self;
+public:
+ ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
+ ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
+ ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
+ operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
+ ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
+ ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
+ LDKReadOnlyNetworkGraph* operator &() { return &self; }
+ LDKReadOnlyNetworkGraph* operator ->() { return &self; }
+ const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
+ const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
+};
+class NetworkUpdate {
+private:
+ LDKNetworkUpdate self;
+public:
+ NetworkUpdate(const NetworkUpdate&) = delete;
+ NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
+ NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
+ operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
+ ~NetworkUpdate() { NetworkUpdate_free(self); }
+ NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
+ LDKNetworkUpdate* operator &() { return &self; }
+ LDKNetworkUpdate* operator ->() { return &self; }
+ const LDKNetworkUpdate* operator &() const { return &self; }
+ const LDKNetworkUpdate* operator ->() const { return &self; }
+};
+class P2PGossipSync {
+private:
+ LDKP2PGossipSync self;
+public:
+ P2PGossipSync(const P2PGossipSync&) = delete;
+ P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
+ P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
+ operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
+ ~P2PGossipSync() { P2PGossipSync_free(self); }
+ P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
+ LDKP2PGossipSync* operator &() { return &self; }
+ LDKP2PGossipSync* operator ->() { return &self; }
+ const LDKP2PGossipSync* operator &() const { return &self; }
+ const LDKP2PGossipSync* operator ->() const { return &self; }
+};
+class ChannelUpdateInfo {
+private:
+ LDKChannelUpdateInfo self;
+public:
+ ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
+ ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
+ ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
+ operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
+ ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
+ ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
+ LDKChannelUpdateInfo* operator &() { return &self; }
+ LDKChannelUpdateInfo* operator ->() { return &self; }
+ const LDKChannelUpdateInfo* operator &() const { return &self; }
+ const LDKChannelUpdateInfo* operator ->() const { return &self; }
+};
+class ChannelInfo {
+private:
+ LDKChannelInfo self;
+public:
+ ChannelInfo(const ChannelInfo&) = delete;
+ ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
+ ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
+ operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
+ ~ChannelInfo() { ChannelInfo_free(self); }
+ ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
+ LDKChannelInfo* operator &() { return &self; }
+ LDKChannelInfo* operator ->() { return &self; }
+ const LDKChannelInfo* operator &() const { return &self; }
+ const LDKChannelInfo* operator ->() const { return &self; }
+};
+class DirectedChannelInfo {
+private:
+ LDKDirectedChannelInfo self;
+public:
+ DirectedChannelInfo(const DirectedChannelInfo&) = delete;
+ DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
+ DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
+ operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
+ ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
+ DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
+ LDKDirectedChannelInfo* operator &() { return &self; }
+ LDKDirectedChannelInfo* operator ->() { return &self; }
+ const LDKDirectedChannelInfo* operator &() const { return &self; }
+ const LDKDirectedChannelInfo* operator ->() const { return &self; }
+};
+class EffectiveCapacity {
+private:
+ LDKEffectiveCapacity self;
+public:
+ EffectiveCapacity(const EffectiveCapacity&) = delete;
+ EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
+ EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
+ operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
+ ~EffectiveCapacity() { EffectiveCapacity_free(self); }
+ EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
+ LDKEffectiveCapacity* operator &() { return &self; }
+ LDKEffectiveCapacity* operator ->() { return &self; }
+ const LDKEffectiveCapacity* operator &() const { return &self; }
+ const LDKEffectiveCapacity* operator ->() const { return &self; }
+};
+class NodeAnnouncementDetails {
+private:
+ LDKNodeAnnouncementDetails self;
+public:
+ NodeAnnouncementDetails(const NodeAnnouncementDetails&) = delete;
+ NodeAnnouncementDetails(NodeAnnouncementDetails&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementDetails)); }
+ NodeAnnouncementDetails(LDKNodeAnnouncementDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementDetails)); }
+ operator LDKNodeAnnouncementDetails() && { LDKNodeAnnouncementDetails res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementDetails)); return res; }
+ ~NodeAnnouncementDetails() { NodeAnnouncementDetails_free(self); }
+ NodeAnnouncementDetails& operator=(NodeAnnouncementDetails&& o) { NodeAnnouncementDetails_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementDetails)); return *this; }
+ LDKNodeAnnouncementDetails* operator &() { return &self; }
+ LDKNodeAnnouncementDetails* operator ->() { return &self; }
+ const LDKNodeAnnouncementDetails* operator &() const { return &self; }
+ const LDKNodeAnnouncementDetails* operator ->() const { return &self; }
+};
+class NodeAnnouncementInfo {
+private:
+ LDKNodeAnnouncementInfo self;
+public:
+ NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
+ NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
+ NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
+ operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
+ ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
+ NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
+ LDKNodeAnnouncementInfo* operator &() { return &self; }
+ LDKNodeAnnouncementInfo* operator ->() { return &self; }
+ const LDKNodeAnnouncementInfo* operator &() const { return &self; }
+ const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
+};
+class NodeAlias {
+private:
+ LDKNodeAlias self;
+public:
+ NodeAlias(const NodeAlias&) = delete;
+ NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
+ NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
+ operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
+ ~NodeAlias() { NodeAlias_free(self); }
+ NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
+ LDKNodeAlias* operator &() { return &self; }
+ LDKNodeAlias* operator ->() { return &self; }
+ const LDKNodeAlias* operator &() const { return &self; }
+ const LDKNodeAlias* operator ->() const { return &self; }
+};
+class NodeInfo {
+private:
+ LDKNodeInfo self;
+public:
+ NodeInfo(const NodeInfo&) = delete;
+ NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
+ NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
+ operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
+ ~NodeInfo() { NodeInfo_free(self); }
+ NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
+ LDKNodeInfo* operator &() { return &self; }
+ LDKNodeInfo* operator ->() { return &self; }
+ const LDKNodeInfo* operator &() const { return &self; }
+ const LDKNodeInfo* operator ->() const { return &self; }
+};
+class ShortChannelIdError {
+private:
+ LDKShortChannelIdError self;
+public:
+ ShortChannelIdError(const ShortChannelIdError&) = delete;
+ ShortChannelIdError(ShortChannelIdError&& o) : self(o.self) { memset(&o, 0, sizeof(ShortChannelIdError)); }
+ ShortChannelIdError(LDKShortChannelIdError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShortChannelIdError)); }
+ operator LDKShortChannelIdError() && { LDKShortChannelIdError res = self; memset(&self, 0, sizeof(LDKShortChannelIdError)); return res; }
+ ShortChannelIdError& operator=(ShortChannelIdError&& o) { self = o.self; memset(&o, 0, sizeof(ShortChannelIdError)); return *this; }
+ LDKShortChannelIdError* operator &() { return &self; }
+ LDKShortChannelIdError* operator ->() { return &self; }
+ const LDKShortChannelIdError* operator &() const { return &self; }
+ const LDKShortChannelIdError* operator ->() const { return &self; }
+};
+class InboundHTLCErr {
+private:
+ LDKInboundHTLCErr self;
+public:
+ InboundHTLCErr(const InboundHTLCErr&) = delete;
+ InboundHTLCErr(InboundHTLCErr&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCErr)); }
+ InboundHTLCErr(LDKInboundHTLCErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCErr)); }
+ operator LDKInboundHTLCErr() && { LDKInboundHTLCErr res = self; memset(&self, 0, sizeof(LDKInboundHTLCErr)); return res; }
+ ~InboundHTLCErr() { InboundHTLCErr_free(self); }
+ InboundHTLCErr& operator=(InboundHTLCErr&& o) { InboundHTLCErr_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCErr)); return *this; }
+ LDKInboundHTLCErr* operator &() { return &self; }
+ LDKInboundHTLCErr* operator ->() { return &self; }
+ const LDKInboundHTLCErr* operator &() const { return &self; }
+ const LDKInboundHTLCErr* operator ->() const { return &self; }
+};
+class AnchorDescriptor {
+private:
+ LDKAnchorDescriptor self;
+public:
+ AnchorDescriptor(const AnchorDescriptor&) = delete;
+ AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
+ AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
+ operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
+ ~AnchorDescriptor() { AnchorDescriptor_free(self); }
+ AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
+ LDKAnchorDescriptor* operator &() { return &self; }
+ LDKAnchorDescriptor* operator ->() { return &self; }
+ const LDKAnchorDescriptor* operator &() const { return &self; }
+ const LDKAnchorDescriptor* operator ->() const { return &self; }
+};
+class BumpTransactionEvent {
+private:
+ LDKBumpTransactionEvent self;
+public:
+ BumpTransactionEvent(const BumpTransactionEvent&) = delete;
+ BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
+ BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
+ operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
+ ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
+ BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
+ LDKBumpTransactionEvent* operator &() { return &self; }
+ LDKBumpTransactionEvent* operator ->() { return &self; }
+ const LDKBumpTransactionEvent* operator &() const { return &self; }
+ const LDKBumpTransactionEvent* operator ->() const { return &self; }
+};
+class Input {
+private:
+ LDKInput self;
+public:
+ Input(const Input&) = delete;
+ Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
+ Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
+ operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
+ ~Input() { Input_free(self); }
+ Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
+ LDKInput* operator &() { return &self; }
+ LDKInput* operator ->() { return &self; }
+ const LDKInput* operator &() const { return &self; }
+ const LDKInput* operator ->() const { return &self; }
+};
+class Utxo {
+private:
+ LDKUtxo self;
+public:
+ Utxo(const Utxo&) = delete;
+ Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
+ Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
+ operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
+ ~Utxo() { Utxo_free(self); }
+ Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
+ LDKUtxo* operator &() { return &self; }
+ LDKUtxo* operator ->() { return &self; }
+ const LDKUtxo* operator &() const { return &self; }
+ const LDKUtxo* operator ->() const { return &self; }
+};
+class CoinSelection {
+private:
+ LDKCoinSelection self;
+public:
+ CoinSelection(const CoinSelection&) = delete;
+ CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
+ CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
+ operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
+ ~CoinSelection() { CoinSelection_free(self); }
+ CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
+ LDKCoinSelection* operator &() { return &self; }
+ LDKCoinSelection* operator ->() { return &self; }
+ const LDKCoinSelection* operator &() const { return &self; }
+ const LDKCoinSelection* operator ->() const { return &self; }
+};
+class CoinSelectionSource {
+private:
+ LDKCoinSelectionSource self;
+public:
+ CoinSelectionSource(const CoinSelectionSource&) = delete;
+ CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
+ CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
+ operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
+ ~CoinSelectionSource() { CoinSelectionSource_free(self); }
+ CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
+ LDKCoinSelectionSource* operator &() { return &self; }
+ LDKCoinSelectionSource* operator ->() { return &self; }
+ const LDKCoinSelectionSource* operator &() const { return &self; }
+ const LDKCoinSelectionSource* operator ->() const { return &self; }
+ /**
+ * Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
+ * available to spend. Implementations are free to pick their coin selection algorithm of
+ * choice, as long as the following requirements are met:
+ *
+ * 1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
+ * throughout coin selection, but must not be returned as part of the result.
+ * 2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
+ * throughout coin selection. In some cases, like when funding an anchor transaction, this
+ * set is empty. Implementations should ensure they handle this correctly on their end,
+ * e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
+ * provided, in which case a zero-value empty OP_RETURN output can be used instead.
+ * 3. Enough inputs must be selected/contributed for the resulting transaction (including the
+ * inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
+ *
+ * Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
+ * the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
+ * providing the full input weight. Failing to do so may lead to underestimating fee bumps and
+ * delaying block inclusion.
+ *
+ * The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
+ * can be re-used within new fee-bumped iterations of the original claiming transaction,
+ * ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
+ * transaction associated with it, and all of the available UTXOs have already been assigned to
+ * other claims, implementations must be willing to double spend their UTXOs. The choice of
+ * which UTXOs to double spend is left to the implementation, but it must strive to keep the
+ * set of other claims being double spent to a minimum.
+ */
+ inline LDK::CResult_CoinSelectionNoneZ select_confirmed_utxos(struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight);
+ /**
+ * Signs and provides the full witness for all inputs within the transaction known to the
+ * trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
+ *
+ * If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+ * unsigned transaction and then sign it with your wallet.
+ */
+ inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
+};
+class WalletSource {
+private:
+ LDKWalletSource self;
+public:
+ WalletSource(const WalletSource&) = delete;
+ WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
+ WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
+ operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
+ ~WalletSource() { WalletSource_free(self); }
+ WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
+ LDKWalletSource* operator &() { return &self; }
+ LDKWalletSource* operator ->() { return &self; }
+ const LDKWalletSource* operator &() const { return &self; }
+ const LDKWalletSource* operator ->() const { return &self; }
+ /**
+ * Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
+ */
+ inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
+ /**
+ * Returns a script to use for change above dust resulting from a successful coin selection
+ * attempt.
+ */
+ inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
+ /**
+ * Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
+ * the transaction known to the wallet (i.e., any provided via
+ * [`WalletSource::list_confirmed_utxos`]).
+ *
+ * If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+ * unsigned transaction and then sign it with your wallet.
+ */
+ inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
+};
+class Wallet {
+private:
+ LDKWallet self;
+public:
+ Wallet(const Wallet&) = delete;
+ Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
+ Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
+ operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
+ ~Wallet() { Wallet_free(self); }
+ Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
+ LDKWallet* operator &() { return &self; }
+ LDKWallet* operator ->() { return &self; }
+ const LDKWallet* operator &() const { return &self; }
+ const LDKWallet* operator ->() const { return &self; }
+};
+class BumpTransactionEventHandler {
+private:
+ LDKBumpTransactionEventHandler self;
+public:
+ BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
+ BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
+ BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
+ operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
+ ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
+ BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
+ LDKBumpTransactionEventHandler* operator &() { return &self; }
+ LDKBumpTransactionEventHandler* operator ->() { return &self; }
+ const LDKBumpTransactionEventHandler* operator &() const { return &self; }
+ const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
+};
+class PendingHTLCRouting {
+private:
+ LDKPendingHTLCRouting self;
+public:
+ PendingHTLCRouting(const PendingHTLCRouting&) = delete;
+ PendingHTLCRouting(PendingHTLCRouting&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCRouting)); }
+ PendingHTLCRouting(LDKPendingHTLCRouting&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCRouting)); }
+ operator LDKPendingHTLCRouting() && { LDKPendingHTLCRouting res = self; memset(&self, 0, sizeof(LDKPendingHTLCRouting)); return res; }
+ ~PendingHTLCRouting() { PendingHTLCRouting_free(self); }
+ PendingHTLCRouting& operator=(PendingHTLCRouting&& o) { PendingHTLCRouting_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCRouting)); return *this; }
+ LDKPendingHTLCRouting* operator &() { return &self; }
+ LDKPendingHTLCRouting* operator ->() { return &self; }
+ const LDKPendingHTLCRouting* operator &() const { return &self; }
+ const LDKPendingHTLCRouting* operator ->() const { return &self; }
+};
+class BlindedForward {
+private:
+ LDKBlindedForward self;
+public:
+ BlindedForward(const BlindedForward&) = delete;
+ BlindedForward(BlindedForward&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedForward)); }
+ BlindedForward(LDKBlindedForward&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedForward)); }
+ operator LDKBlindedForward() && { LDKBlindedForward res = self; memset(&self, 0, sizeof(LDKBlindedForward)); return res; }
+ ~BlindedForward() { BlindedForward_free(self); }
+ BlindedForward& operator=(BlindedForward&& o) { BlindedForward_free(self); self = o.self; memset(&o, 0, sizeof(BlindedForward)); return *this; }
+ LDKBlindedForward* operator &() { return &self; }
+ LDKBlindedForward* operator ->() { return &self; }
+ const LDKBlindedForward* operator &() const { return &self; }
+ const LDKBlindedForward* operator ->() const { return &self; }
+};
+class PendingHTLCInfo {
+private:
+ LDKPendingHTLCInfo self;
+public:
+ PendingHTLCInfo(const PendingHTLCInfo&) = delete;
+ PendingHTLCInfo(PendingHTLCInfo&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCInfo)); }
+ PendingHTLCInfo(LDKPendingHTLCInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCInfo)); }
+ operator LDKPendingHTLCInfo() && { LDKPendingHTLCInfo res = self; memset(&self, 0, sizeof(LDKPendingHTLCInfo)); return res; }
+ ~PendingHTLCInfo() { PendingHTLCInfo_free(self); }
+ PendingHTLCInfo& operator=(PendingHTLCInfo&& o) { PendingHTLCInfo_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCInfo)); return *this; }
+ LDKPendingHTLCInfo* operator &() { return &self; }
+ LDKPendingHTLCInfo* operator ->() { return &self; }
+ const LDKPendingHTLCInfo* operator &() const { return &self; }
+ const LDKPendingHTLCInfo* operator ->() const { return &self; }
+};
+class BlindedFailure {
+private:
+ LDKBlindedFailure self;
+public:
+ BlindedFailure(const BlindedFailure&) = delete;
+ BlindedFailure(BlindedFailure&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedFailure)); }
+ BlindedFailure(LDKBlindedFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedFailure)); }
+ operator LDKBlindedFailure() && { LDKBlindedFailure res = self; memset(&self, 0, sizeof(LDKBlindedFailure)); return res; }
+ BlindedFailure& operator=(BlindedFailure&& o) { self = o.self; memset(&o, 0, sizeof(BlindedFailure)); return *this; }
+ LDKBlindedFailure* operator &() { return &self; }
+ LDKBlindedFailure* operator ->() { return &self; }
+ const LDKBlindedFailure* operator &() const { return &self; }
+ const LDKBlindedFailure* operator ->() const { return &self; }
+};
+class FailureCode {
+private:
+ LDKFailureCode self;
+public:
+ FailureCode(const FailureCode&) = delete;
+ FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
+ FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
+ operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
+ ~FailureCode() { FailureCode_free(self); }
+ FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
+ LDKFailureCode* operator &() { return &self; }
+ LDKFailureCode* operator ->() { return &self; }
+ const LDKFailureCode* operator &() const { return &self; }
+ const LDKFailureCode* operator ->() const { return &self; }
+};
+class ChannelManager {
+private:
+ LDKChannelManager self;
+public:
+ ChannelManager(const ChannelManager&) = delete;
+ ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
+ ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
+ operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
+ ~ChannelManager() { ChannelManager_free(self); }
+ ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
+ LDKChannelManager* operator &() { return &self; }
+ LDKChannelManager* operator ->() { return &self; }
+ const LDKChannelManager* operator &() const { return &self; }
+ const LDKChannelManager* operator ->() const { return &self; }
+};
+class ChainParameters {
+private:
+ LDKChainParameters self;
+public:
+ ChainParameters(const ChainParameters&) = delete;
+ ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
+ ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
+ operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
+ ~ChainParameters() { ChainParameters_free(self); }
+ ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
+ LDKChainParameters* operator &() { return &self; }
+ LDKChainParameters* operator ->() { return &self; }
+ const LDKChainParameters* operator &() const { return &self; }
+ const LDKChainParameters* operator ->() const { return &self; }
+};
+class RecentPaymentDetails {
+private:
+ LDKRecentPaymentDetails self;
+public:
+ RecentPaymentDetails(const RecentPaymentDetails&) = delete;
+ RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
+ RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
+ operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
+ ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
+ RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
+ LDKRecentPaymentDetails* operator &() { return &self; }
+ LDKRecentPaymentDetails* operator ->() { return &self; }
+ const LDKRecentPaymentDetails* operator &() const { return &self; }
+ const LDKRecentPaymentDetails* operator ->() const { return &self; }
+};
+class PhantomRouteHints {
+private:
+ LDKPhantomRouteHints self;
+public:
+ PhantomRouteHints(const PhantomRouteHints&) = delete;
+ PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
+ PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
+ operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
+ ~PhantomRouteHints() { PhantomRouteHints_free(self); }
+ PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
+ LDKPhantomRouteHints* operator &() { return &self; }
+ LDKPhantomRouteHints* operator ->() { return &self; }
+ const LDKPhantomRouteHints* operator &() const { return &self; }
+ const LDKPhantomRouteHints* operator ->() const { return &self; }
+};
+class ChannelManagerReadArgs {
+private:
+ LDKChannelManagerReadArgs self;
+public:
+ ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
+ ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
+ ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
+ operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
+ ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
+ ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
+ LDKChannelManagerReadArgs* operator &() { return &self; }
+ LDKChannelManagerReadArgs* operator ->() { return &self; }
+ const LDKChannelManagerReadArgs* operator &() const { return &self; }
+ const LDKChannelManagerReadArgs* operator ->() const { return &self; }
+};
+class ChannelHandshakeConfig {
+private:
+ LDKChannelHandshakeConfig self;
+public:
+ ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
+ ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
+ ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
+ operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
+ ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
+ ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
+ LDKChannelHandshakeConfig* operator &() { return &self; }
+ LDKChannelHandshakeConfig* operator ->() { return &self; }
+ const LDKChannelHandshakeConfig* operator &() const { return &self; }
+ const LDKChannelHandshakeConfig* operator ->() const { return &self; }
+};
+class ChannelHandshakeLimits {
+private:
+ LDKChannelHandshakeLimits self;
+public:
+ ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
+ ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
+ ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
+ operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
+ ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
+ ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
+ LDKChannelHandshakeLimits* operator &() { return &self; }
+ LDKChannelHandshakeLimits* operator ->() { return &self; }
+ const LDKChannelHandshakeLimits* operator &() const { return &self; }
+ const LDKChannelHandshakeLimits* operator ->() const { return &self; }
+};
+class MaxDustHTLCExposure {
+private:
+ LDKMaxDustHTLCExposure self;
+public:
+ MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
+ MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
+ MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
+ operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
+ ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
+ MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
+ LDKMaxDustHTLCExposure* operator &() { return &self; }
+ LDKMaxDustHTLCExposure* operator ->() { return &self; }
+ const LDKMaxDustHTLCExposure* operator &() const { return &self; }
+ const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
+};
+class ChannelConfig {
+private:
+ LDKChannelConfig self;
+public:
+ ChannelConfig(const ChannelConfig&) = delete;
+ ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
+ ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
+ operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
+ ~ChannelConfig() { ChannelConfig_free(self); }
+ ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
+ LDKChannelConfig* operator &() { return &self; }
+ LDKChannelConfig* operator ->() { return &self; }
+ const LDKChannelConfig* operator &() const { return &self; }
+ const LDKChannelConfig* operator ->() const { return &self; }
+};
+class ChannelConfigUpdate {
+private:
+ LDKChannelConfigUpdate self;
+public:
+ ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
+ ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
+ ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
+ operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
+ ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
+ ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
+ LDKChannelConfigUpdate* operator &() { return &self; }
+ LDKChannelConfigUpdate* operator ->() { return &self; }
+ const LDKChannelConfigUpdate* operator &() const { return &self; }
+ const LDKChannelConfigUpdate* operator ->() const { return &self; }
+};
+class UserConfig {
+private:
+ LDKUserConfig self;
+public:
+ UserConfig(const UserConfig&) = delete;
+ UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
+ UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
+ operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
+ ~UserConfig() { UserConfig_free(self); }
+ UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
+ LDKUserConfig* operator &() { return &self; }
+ LDKUserConfig* operator ->() { return &self; }
+ const LDKUserConfig* operator &() const { return &self; }
+ const LDKUserConfig* operator ->() const { return &self; }
+};
+class APIError {
+private:
+ LDKAPIError self;
+public:
+ APIError(const APIError&) = delete;
+ APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
+ APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
+ operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
+ ~APIError() { APIError_free(self); }
+ APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
+ LDKAPIError* operator &() { return &self; }
+ LDKAPIError* operator ->() { return &self; }
+ const LDKAPIError* operator &() const { return &self; }
+ const LDKAPIError* operator ->() const { return &self; }
+};
+class TaggedHash {
+private:
+ LDKTaggedHash self;
+public:
+ TaggedHash(const TaggedHash&) = delete;
+ TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
+ TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
+ operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
+ ~TaggedHash() { TaggedHash_free(self); }
+ TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
+ LDKTaggedHash* operator &() { return &self; }
+ LDKTaggedHash* operator ->() { return &self; }
+ const LDKTaggedHash* operator &() const { return &self; }
+ const LDKTaggedHash* operator ->() const { return &self; }
+};
+class SignError {
+private:
+ LDKSignError self;
+public:
+ SignError(const SignError&) = delete;
+ SignError(SignError&& o) : self(o.self) { memset(&o, 0, sizeof(SignError)); }
+ SignError(LDKSignError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignError)); }
+ operator LDKSignError() && { LDKSignError res = self; memset(&self, 0, sizeof(LDKSignError)); return res; }
+ ~SignError() { SignError_free(self); }
+ SignError& operator=(SignError&& o) { SignError_free(self); self = o.self; memset(&o, 0, sizeof(SignError)); return *this; }
+ LDKSignError* operator &() { return &self; }
+ LDKSignError* operator ->() { return &self; }
+ const LDKSignError* operator &() const { return &self; }
+ const LDKSignError* operator ->() const { return &self; }
+};
+class EcdsaChannelSigner {
+private:
+ LDKEcdsaChannelSigner self;
+public:
+ EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
+ EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
+ EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
+ operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
+ ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
+ EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
+ LDKEcdsaChannelSigner* operator &() { return &self; }
+ LDKEcdsaChannelSigner* operator ->() { return &self; }
+ const LDKEcdsaChannelSigner* operator &() const { return &self; }
+ const LDKEcdsaChannelSigner* operator ->() const { return &self; }
+ /**
+ * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
+ *
+ * Note that if signing fails or is rejected, the channel will be force-closed.
+ *
+ * Policy checks should be implemented in this function, including checking the amount
+ * sent to us and checking the HTLCs.
+ *
+ * The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
+ * are provided. A validating signer should ensure that an outbound HTLC output is removed
+ * only when the matching preimage is provided and after the corresponding inbound HTLC has
+ * been removed for forwarded payments.
+ *
+ * Note that all the relevant preimages will be provided, but there may also be additional
+ * irrelevant or duplicate preimages.
+ */
+ inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
+ /**
+ * Creates a signature for a holder's commitment transaction.
+ *
+ * This will be called
+ * - with a non-revoked `commitment_tx`.
+ * - with the latest `commitment_tx` when we initiate a force-close.
+ *
+ * This may be called multiple times for the same transaction.
+ *
+ * An external signer implementation should check that the commitment has not been revoked.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
+ /**
+ * Create a signature for the given input in a transaction spending an HTLC transaction output
+ * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
+ *
+ * A justice transaction may claim multiple outputs at the same time if timelocks are
+ * similar, but only a signature for the input at index `input` should be signed for here.
+ * It may be called multiple times for same output(s) if a fee-bump is needed with regards
+ * to an upcoming timelock expiration.
+ *
+ * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+ *
+ * `per_commitment_key` is revocation secret which was provided by our counterparty when they
+ * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+ * not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
+ * so).
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
+ /**
+ * Create a signature for the given input in a transaction spending a commitment transaction
+ * HTLC output when our counterparty broadcasts an old state.
+ *
+ * A justice transaction may claim multiple outputs at the same time if timelocks are
+ * similar, but only a signature for the input at index `input` should be signed for here.
+ * It may be called multiple times for same output(s) if a fee-bump is needed with regards
+ * to an upcoming timelock expiration.
+ *
+ * `amount` is the value of the output spent by this input, committed to in the BIP 143
+ * signature.
+ *
+ * `per_commitment_key` is revocation secret which was provided by our counterparty when they
+ * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+ * not allow the spending of any funds by itself (you need our holder revocation_secret to do
+ * so).
+ *
+ * `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
+ * (which is committed to in the BIP 143 signatures).
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
+ /**
+ * Computes the signature for a commitment transaction's HTLC output used as an input within
+ * `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
+ * must be be computed using [`EcdsaSighashType::All`].
+ *
+ * Note that this may be called for HTLCs in the penultimate commitment transaction if a
+ * [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
+ * broadcasts it before receiving the update for the latest commitment transaction.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
+ * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
+ /**
+ * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
+ * transaction, either offered or received.
+ *
+ * Such a transaction may claim multiples offered outputs at same time if we know the
+ * preimage for each when we create it, but only the input at index `input` should be
+ * signed for here. It may be called multiple times for same output(s) if a fee-bump is
+ * needed with regards to an upcoming timelock expiration.
+ *
+ * `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
+ * outputs.
+ *
+ * `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
+ *
+ * `per_commitment_point` is the dynamic point corresponding to the channel state
+ * detected onchain. It has been generated by our counterparty and is used to derive
+ * channel state keys, which are then included in the witness script and committed to in the
+ * BIP 143 signature.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
+ /**
+ * Create a signature for a (proposed) closing transaction.
+ *
+ * Note that, due to rounding, there may be one "missing" satoshi, and either party may have
+ * chosen to forgo their output as dust.
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
+ /**
+ * Computes the signature for a commitment transaction's anchor output used as an
+ * input within `anchor_tx`, which spends the commitment transaction, at index `input`.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
+ /**
+ * Signs a channel announcement message with our funding key proving it comes from one of the
+ * channel participants.
+ *
+ * Channel announcements also require a signature from each node's network key. Our node
+ * signature is computed through [`NodeSigner::sign_gossip_message`].
+ *
+ * Note that if this fails or is rejected, the channel will not be publicly announced and
+ * our counterparty may (though likely will not) close the channel on us for violating the
+ * protocol.
+ *
+ * [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+};
+class ChannelMonitorUpdate {
+private:
+ LDKChannelMonitorUpdate self;
+public:
+ ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
+ ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
+ ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
+ operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
+ ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
+ ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
+ LDKChannelMonitorUpdate* operator &() { return &self; }
+ LDKChannelMonitorUpdate* operator ->() { return &self; }
+ const LDKChannelMonitorUpdate* operator &() const { return &self; }
+ const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+};
+class MonitorEvent {
+private:
+ LDKMonitorEvent self;
+public:
+ MonitorEvent(const MonitorEvent&) = delete;
+ MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
+ MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
+ operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
+ ~MonitorEvent() { MonitorEvent_free(self); }
+ MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
+ LDKMonitorEvent* operator &() { return &self; }
+ LDKMonitorEvent* operator ->() { return &self; }
+ const LDKMonitorEvent* operator &() const { return &self; }
+ const LDKMonitorEvent* operator ->() const { return &self; }
+};
+class HTLCUpdate {
+private:
+ LDKHTLCUpdate self;
+public:
+ HTLCUpdate(const HTLCUpdate&) = delete;
+ HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
+ HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
+ operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
+ ~HTLCUpdate() { HTLCUpdate_free(self); }
+ HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
+ LDKHTLCUpdate* operator &() { return &self; }
+ LDKHTLCUpdate* operator ->() { return &self; }
+ const LDKHTLCUpdate* operator &() const { return &self; }
+ const LDKHTLCUpdate* operator ->() const { return &self; }
+};
+class BalanceSource {
+private:
+ LDKBalanceSource self;
+public:
+ BalanceSource(const BalanceSource&) = delete;
+ BalanceSource(BalanceSource&& o) : self(o.self) { memset(&o, 0, sizeof(BalanceSource)); }
+ BalanceSource(LDKBalanceSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalanceSource)); }
+ operator LDKBalanceSource() && { LDKBalanceSource res = self; memset(&self, 0, sizeof(LDKBalanceSource)); return res; }
+ BalanceSource& operator=(BalanceSource&& o) { self = o.self; memset(&o, 0, sizeof(BalanceSource)); return *this; }
+ LDKBalanceSource* operator &() { return &self; }
+ LDKBalanceSource* operator ->() { return &self; }
+ const LDKBalanceSource* operator &() const { return &self; }
+ const LDKBalanceSource* operator ->() const { return &self; }
+};
+class Balance {
+private:
+ LDKBalance self;
+public:
+ Balance(const Balance&) = delete;
+ Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
+ Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
+ operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
+ ~Balance() { Balance_free(self); }
+ Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
+ LDKBalance* operator &() { return &self; }
+ LDKBalance* operator ->() { return &self; }
+ const LDKBalance* operator &() const { return &self; }
+ const LDKBalance* operator ->() const { return &self; }
+};
+class ChannelMonitor {
+private:
+ LDKChannelMonitor self;
+public:
+ ChannelMonitor(const ChannelMonitor&) = delete;
+ ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
+ ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
+ operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
+ ~ChannelMonitor() { ChannelMonitor_free(self); }
+ ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
+ LDKChannelMonitor* operator &() { return &self; }
+ LDKChannelMonitor* operator ->() { return &self; }
+ const LDKChannelMonitor* operator &() const { return &self; }
+ const LDKChannelMonitor* operator ->() const { return &self; }
+};
+class ExpandedKey {
+private:
+ LDKExpandedKey self;
+public:
+ ExpandedKey(const ExpandedKey&) = delete;
+ ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
+ ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
+ operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
+ ~ExpandedKey() { ExpandedKey_free(self); }
+ ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
+ LDKExpandedKey* operator &() { return &self; }
+ LDKExpandedKey* operator ->() { return &self; }
+ const LDKExpandedKey* operator &() const { return &self; }
+ const LDKExpandedKey* operator ->() const { return &self; }
+};
+class CustomMessageHandler {
+private:
+ LDKCustomMessageHandler self;
+public:
+ CustomMessageHandler(const CustomMessageHandler&) = delete;
+ CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
+ CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
+ operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
+ ~CustomMessageHandler() { CustomMessageHandler_free(self); }
+ CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
+ LDKCustomMessageHandler* operator &() { return &self; }
+ LDKCustomMessageHandler* operator ->() { return &self; }
+ const LDKCustomMessageHandler* operator &() const { return &self; }
+ const LDKCustomMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handles the given message sent from `sender_node_id`, possibly producing messages for
+ * [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
+ * to send.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
+ /**
+ * Returns the list of pending messages that were generated by the handler, clearing the list
+ * in the process. Each message is paired with the node id of the intended recipient. If no
+ * connection to the node exists, then the message is simply not sent.
+ */
+ inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
+ /**
+ * Indicates a peer disconnected.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Handle a peer connecting.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ *
+ * [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * [`Init`]: crate::ln::msgs::Init
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class IgnoringMessageHandler {
+private:
+ LDKIgnoringMessageHandler self;
+public:
+ IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
+ IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
+ IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
+ operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
+ ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
+ IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
+ LDKIgnoringMessageHandler* operator &() { return &self; }
+ LDKIgnoringMessageHandler* operator ->() { return &self; }
+ const LDKIgnoringMessageHandler* operator &() const { return &self; }
+ const LDKIgnoringMessageHandler* operator ->() const { return &self; }
+};
+class ErroringMessageHandler {
+private:
+ LDKErroringMessageHandler self;
+public:
+ ErroringMessageHandler(const ErroringMessageHandler&) = delete;
+ ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
+ ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
+ operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
+ ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
+ ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
+ LDKErroringMessageHandler* operator &() { return &self; }
+ LDKErroringMessageHandler* operator ->() { return &self; }
+ const LDKErroringMessageHandler* operator &() const { return &self; }
+ const LDKErroringMessageHandler* operator ->() const { return &self; }
+};
+class MessageHandler {
+private:
+ LDKMessageHandler self;
+public:
+ MessageHandler(const MessageHandler&) = delete;
+ MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
+ MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
+ operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
+ ~MessageHandler() { MessageHandler_free(self); }
+ MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
+ LDKMessageHandler* operator &() { return &self; }
+ LDKMessageHandler* operator ->() { return &self; }
+ const LDKMessageHandler* operator &() const { return &self; }
+ const LDKMessageHandler* operator ->() const { return &self; }
+};
+class SocketDescriptor {
+private:
+ LDKSocketDescriptor self;
+public:
+ SocketDescriptor(const SocketDescriptor&) = delete;
+ SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
+ SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
+ operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
+ ~SocketDescriptor() { SocketDescriptor_free(self); }
+ SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
+ LDKSocketDescriptor* operator &() { return &self; }
+ LDKSocketDescriptor* operator ->() { return &self; }
+ const LDKSocketDescriptor* operator &() const { return &self; }
+ const LDKSocketDescriptor* operator ->() const { return &self; }
+ /**
+ * Attempts to send some data from the given slice to the peer.
+ *
+ * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
+ * Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
+ * called and further write attempts may occur until that time.
+ *
+ * If the returned size is smaller than `data.len()`, a
+ * [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
+ * written. Additionally, until a `send_data` event completes fully, no further
+ * [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
+ * prevent denial-of-service issues, you should not read or buffer any data from the socket
+ * until then.
+ *
+ * If a [`PeerManager::read_event`] call on this descriptor had previously returned true
+ * (indicating that read events should be paused to prevent DoS in the send buffer),
+ * `resume_read` may be set indicating that read events on this descriptor should resume. A
+ * `resume_read` of false carries no meaning, and should not cause any action.
+ */
+ inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
+ /**
+ * Disconnect the socket pointed to by this SocketDescriptor.
+ *
+ * You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
+ * call (doing so is a noop).
+ */
+ inline void disconnect_socket();
+ /** Checks if two objects are equal given this object's this_arg pointer and another object. */
+ inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
+ /**
+ * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
+ * This is used, for example, for inclusion of this object in a hash map.
+ */
+ inline uint64_t hash();
+};
+class PeerDetails {
+private:
+ LDKPeerDetails self;
+public:
+ PeerDetails(const PeerDetails&) = delete;
+ PeerDetails(PeerDetails&& o) : self(o.self) { memset(&o, 0, sizeof(PeerDetails)); }
+ PeerDetails(LDKPeerDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerDetails)); }
+ operator LDKPeerDetails() && { LDKPeerDetails res = self; memset(&self, 0, sizeof(LDKPeerDetails)); return res; }
+ ~PeerDetails() { PeerDetails_free(self); }
+ PeerDetails& operator=(PeerDetails&& o) { PeerDetails_free(self); self = o.self; memset(&o, 0, sizeof(PeerDetails)); return *this; }
+ LDKPeerDetails* operator &() { return &self; }
+ LDKPeerDetails* operator ->() { return &self; }
+ const LDKPeerDetails* operator &() const { return &self; }
+ const LDKPeerDetails* operator ->() const { return &self; }
+};
+class PeerHandleError {
+private:
+ LDKPeerHandleError self;
+public:
+ PeerHandleError(const PeerHandleError&) = delete;
+ PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
+ PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
+ operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
+ ~PeerHandleError() { PeerHandleError_free(self); }
+ PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
+ LDKPeerHandleError* operator &() { return &self; }
+ LDKPeerHandleError* operator ->() { return &self; }
+ const LDKPeerHandleError* operator &() const { return &self; }
+ const LDKPeerHandleError* operator ->() const { return &self; }
+};
+class PeerManager {
+private:
+ LDKPeerManager self;
+public:
+ PeerManager(const PeerManager&) = delete;
+ PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
+ PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
+ operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
+ ~PeerManager() { PeerManager_free(self); }
+ PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
+ LDKPeerManager* operator &() { return &self; }
+ LDKPeerManager* operator ->() { return &self; }
+ const LDKPeerManager* operator &() const { return &self; }
+ const LDKPeerManager* operator ->() const { return &self; }
+};
+class GraphSyncError {
+private:
+ LDKGraphSyncError self;
+public:
+ GraphSyncError(const GraphSyncError&) = delete;
+ GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
+ GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
+ operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
+ ~GraphSyncError() { GraphSyncError_free(self); }
+ GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
+ LDKGraphSyncError* operator &() { return &self; }
+ LDKGraphSyncError* operator ->() { return &self; }
+ const LDKGraphSyncError* operator &() const { return &self; }
+ const LDKGraphSyncError* operator ->() const { return &self; }
+};
+class RapidGossipSync {
+private:
+ LDKRapidGossipSync self;
+public:
+ RapidGossipSync(const RapidGossipSync&) = delete;
+ RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
+ RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
+ operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
+ ~RapidGossipSync() { RapidGossipSync_free(self); }
+ RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
+ LDKRapidGossipSync* operator &() { return &self; }
+ LDKRapidGossipSync* operator ->() { return &self; }
+ const LDKRapidGossipSync* operator &() const { return &self; }
+ const LDKRapidGossipSync* operator ->() const { return &self; }
+};
+class KVStore {
+private:
+ LDKKVStore self;
+public:
+ KVStore(const KVStore&) = delete;
+ KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
+ KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
+ operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
+ ~KVStore() { KVStore_free(self); }
+ KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
+ LDKKVStore* operator &() { return &self; }
+ LDKKVStore* operator ->() { return &self; }
+ const LDKKVStore* operator &() const { return &self; }
+ const LDKKVStore* operator ->() const { return &self; }
+ /**
+ * Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
+ * `key`.
+ *
+ * Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
+ * `primary_namespace` and `secondary_namespace`.
+ *
+ * [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
+ */
+ inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
+ /**
+ * Persists the given data under the given `key`.
+ *
+ * Will create the given `primary_namespace` and `secondary_namespace` if not already present
+ * in the store.
+ */
+ inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
+ /**
+ * Removes any data that had previously been persisted under the given `key`.
+ *
+ * If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
+ * remove the given `key` at some point in time after the method returns, e.g., as part of an
+ * eventual batch deletion of multiple keys. As a consequence, subsequent calls to
+ * [`KVStore::list`] might include the removed key until the changes are actually persisted.
+ *
+ * Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
+ * `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
+ * potentially get lost on crash after the method returns. Therefore, this flag should only be
+ * set for `remove` operations that can be safely replayed at a later time.
+ *
+ * Returns successfully if no data will be stored for the given `primary_namespace`,
+ * `secondary_namespace`, and `key`, independently of whether it was present before its
+ * invokation or not.
+ */
+ inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
+ /**
+ * Returns a list of keys that are stored under the given `secondary_namespace` in
+ * `primary_namespace`.
+ *
+ * Returns the keys in arbitrary order, so users requiring a particular order need to sort the
+ * returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
+ */
+ inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
+};
+class Persister {
+private:
+ LDKPersister self;
+public:
+ Persister(const Persister&) = delete;
+ Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
+ Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
+ operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
+ ~Persister() { Persister_free(self); }
+ Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
+ LDKPersister* operator &() { return &self; }
+ LDKPersister* operator ->() { return &self; }
+ const LDKPersister* operator &() const { return &self; }
+ const LDKPersister* operator ->() const { return &self; }
+ /**
+ * Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
+ *
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ */
+ inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
+ /**
+ * Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
+ */
+ inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
+ /**
+ * Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
+ */
+ inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
+};
+class MonitorUpdatingPersister {
+private:
+ LDKMonitorUpdatingPersister self;
+public:
+ MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
+ MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
+ MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
+ operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
+ ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
+ MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
+ LDKMonitorUpdatingPersister* operator &() { return &self; }
+ LDKMonitorUpdatingPersister* operator ->() { return &self; }
+ const LDKMonitorUpdatingPersister* operator &() const { return &self; }
+ const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
+};
+class InvoiceRequestWithExplicitPayerIdBuilder {
+private:
+ LDKInvoiceRequestWithExplicitPayerIdBuilder self;
+public:
+ InvoiceRequestWithExplicitPayerIdBuilder(const InvoiceRequestWithExplicitPayerIdBuilder&) = delete;
+ InvoiceRequestWithExplicitPayerIdBuilder(InvoiceRequestWithExplicitPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); }
+ InvoiceRequestWithExplicitPayerIdBuilder(LDKInvoiceRequestWithExplicitPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); }
+ operator LDKInvoiceRequestWithExplicitPayerIdBuilder() && { LDKInvoiceRequestWithExplicitPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); return res; }
+ ~InvoiceRequestWithExplicitPayerIdBuilder() { InvoiceRequestWithExplicitPayerIdBuilder_free(self); }
+ InvoiceRequestWithExplicitPayerIdBuilder& operator=(InvoiceRequestWithExplicitPayerIdBuilder&& o) { InvoiceRequestWithExplicitPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); return *this; }
+ LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() { return &self; }
+ LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() { return &self; }
+ const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() const { return &self; }
+ const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() const { return &self; }
+};
+class InvoiceRequestWithDerivedPayerIdBuilder {
+private:
+ LDKInvoiceRequestWithDerivedPayerIdBuilder self;
+public:
+ InvoiceRequestWithDerivedPayerIdBuilder(const InvoiceRequestWithDerivedPayerIdBuilder&) = delete;
+ InvoiceRequestWithDerivedPayerIdBuilder(InvoiceRequestWithDerivedPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); }
+ InvoiceRequestWithDerivedPayerIdBuilder(LDKInvoiceRequestWithDerivedPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); }
+ operator LDKInvoiceRequestWithDerivedPayerIdBuilder() && { LDKInvoiceRequestWithDerivedPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); return res; }
+ ~InvoiceRequestWithDerivedPayerIdBuilder() { InvoiceRequestWithDerivedPayerIdBuilder_free(self); }
+ InvoiceRequestWithDerivedPayerIdBuilder& operator=(InvoiceRequestWithDerivedPayerIdBuilder&& o) { InvoiceRequestWithDerivedPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); return *this; }
+ LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() { return &self; }
+ LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() { return &self; }
+ const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() const { return &self; }
+ const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() const { return &self; }
+};
+class UnsignedInvoiceRequest {
+private:
+ LDKUnsignedInvoiceRequest self;
+public:
+ UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
+ UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
+ UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
+ operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
+ ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
+ UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
+ LDKUnsignedInvoiceRequest* operator &() { return &self; }
+ LDKUnsignedInvoiceRequest* operator ->() { return &self; }
+ const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
+ const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
+};
+class SignInvoiceRequestFn {
+private:
+ LDKSignInvoiceRequestFn self;
+public:
+ SignInvoiceRequestFn(const SignInvoiceRequestFn&) = delete;
+ SignInvoiceRequestFn(SignInvoiceRequestFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignInvoiceRequestFn)); }
+ SignInvoiceRequestFn(LDKSignInvoiceRequestFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignInvoiceRequestFn)); }
+ operator LDKSignInvoiceRequestFn() && { LDKSignInvoiceRequestFn res = self; memset(&self, 0, sizeof(LDKSignInvoiceRequestFn)); return res; }
+ ~SignInvoiceRequestFn() { SignInvoiceRequestFn_free(self); }
+ SignInvoiceRequestFn& operator=(SignInvoiceRequestFn&& o) { SignInvoiceRequestFn_free(self); self = o.self; memset(&o, 0, sizeof(SignInvoiceRequestFn)); return *this; }
+ LDKSignInvoiceRequestFn* operator &() { return &self; }
+ LDKSignInvoiceRequestFn* operator ->() { return &self; }
+ const LDKSignInvoiceRequestFn* operator &() const { return &self; }
+ const LDKSignInvoiceRequestFn* operator ->() const { return &self; }
+ /**
+ * Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message);
+};
+class InvoiceRequest {
+private:
+ LDKInvoiceRequest self;
+public:
+ InvoiceRequest(const InvoiceRequest&) = delete;
+ InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
+ InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
+ operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
+ ~InvoiceRequest() { InvoiceRequest_free(self); }
+ InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
+ LDKInvoiceRequest* operator &() { return &self; }
+ LDKInvoiceRequest* operator ->() { return &self; }
+ const LDKInvoiceRequest* operator &() const { return &self; }
+ const LDKInvoiceRequest* operator ->() const { return &self; }
+};
+class VerifiedInvoiceRequest {
+private:
+ LDKVerifiedInvoiceRequest self;
+public:
+ VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
+ VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
+ VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
+ operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
+ ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
+ VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
+ LDKVerifiedInvoiceRequest* operator &() { return &self; }
+ LDKVerifiedInvoiceRequest* operator ->() { return &self; }
+ const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
+ const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
+};
+class InvoiceRequestFields {
+private:
+ LDKInvoiceRequestFields self;
+public:
+ InvoiceRequestFields(const InvoiceRequestFields&) = delete;
+ InvoiceRequestFields(InvoiceRequestFields&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFields)); }
+ InvoiceRequestFields(LDKInvoiceRequestFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFields)); }
+ operator LDKInvoiceRequestFields() && { LDKInvoiceRequestFields res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFields)); return res; }
+ ~InvoiceRequestFields() { InvoiceRequestFields_free(self); }
+ InvoiceRequestFields& operator=(InvoiceRequestFields&& o) { InvoiceRequestFields_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFields)); return *this; }
+ LDKInvoiceRequestFields* operator &() { return &self; }
+ LDKInvoiceRequestFields* operator ->() { return &self; }
+ const LDKInvoiceRequestFields* operator &() const { return &self; }
+ const LDKInvoiceRequestFields* operator ->() const { return &self; }
+};
+class DecodeError {
+private:
+ LDKDecodeError self;
+public:
+ DecodeError(const DecodeError&) = delete;
+ DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
+ DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
+ operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
+ ~DecodeError() { DecodeError_free(self); }
+ DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
+ LDKDecodeError* operator &() { return &self; }
+ LDKDecodeError* operator ->() { return &self; }
+ const LDKDecodeError* operator &() const { return &self; }
+ const LDKDecodeError* operator ->() const { return &self; }
+};
+class Init {
+private:
+ LDKInit self;
+public:
+ Init(const Init&) = delete;
+ Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
+ Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
+ operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
+ ~Init() { Init_free(self); }
+ Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
+ LDKInit* operator &() { return &self; }
+ LDKInit* operator ->() { return &self; }
+ const LDKInit* operator &() const { return &self; }
+ const LDKInit* operator ->() const { return &self; }
+};
+class ErrorMessage {
+private:
+ LDKErrorMessage self;
+public:
+ ErrorMessage(const ErrorMessage&) = delete;
+ ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
+ ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
+ operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
+ ~ErrorMessage() { ErrorMessage_free(self); }
+ ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
+ LDKErrorMessage* operator &() { return &self; }
+ LDKErrorMessage* operator ->() { return &self; }
+ const LDKErrorMessage* operator &() const { return &self; }
+ const LDKErrorMessage* operator ->() const { return &self; }
+};
+class WarningMessage {
+private:
+ LDKWarningMessage self;
+public:
+ WarningMessage(const WarningMessage&) = delete;
+ WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
+ WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
+ operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
+ ~WarningMessage() { WarningMessage_free(self); }
+ WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
+ LDKWarningMessage* operator &() { return &self; }
+ LDKWarningMessage* operator ->() { return &self; }
+ const LDKWarningMessage* operator &() const { return &self; }
+ const LDKWarningMessage* operator ->() const { return &self; }
+};
+class Ping {
+private:
+ LDKPing self;
+public:
+ Ping(const Ping&) = delete;
+ Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
+ Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
+ operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
+ ~Ping() { Ping_free(self); }
+ Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
+ LDKPing* operator &() { return &self; }
+ LDKPing* operator ->() { return &self; }
+ const LDKPing* operator &() const { return &self; }
+ const LDKPing* operator ->() const { return &self; }
+};
+class Pong {
+private:
+ LDKPong self;
+public:
+ Pong(const Pong&) = delete;
+ Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
+ Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
+ operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
+ ~Pong() { Pong_free(self); }
+ Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
+ LDKPong* operator &() { return &self; }
+ LDKPong* operator ->() { return &self; }
+ const LDKPong* operator &() const { return &self; }
+ const LDKPong* operator ->() const { return &self; }
+};
+class CommonOpenChannelFields {
+private:
+ LDKCommonOpenChannelFields self;
+public:
+ CommonOpenChannelFields(const CommonOpenChannelFields&) = delete;
+ CommonOpenChannelFields(CommonOpenChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonOpenChannelFields)); }
+ CommonOpenChannelFields(LDKCommonOpenChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonOpenChannelFields)); }
+ operator LDKCommonOpenChannelFields() && { LDKCommonOpenChannelFields res = self; memset(&self, 0, sizeof(LDKCommonOpenChannelFields)); return res; }
+ ~CommonOpenChannelFields() { CommonOpenChannelFields_free(self); }
+ CommonOpenChannelFields& operator=(CommonOpenChannelFields&& o) { CommonOpenChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonOpenChannelFields)); return *this; }
+ LDKCommonOpenChannelFields* operator &() { return &self; }
+ LDKCommonOpenChannelFields* operator ->() { return &self; }
+ const LDKCommonOpenChannelFields* operator &() const { return &self; }
+ const LDKCommonOpenChannelFields* operator ->() const { return &self; }
+};
+class ChannelParameters {
+private:
+ LDKChannelParameters self;
+public:
+ ChannelParameters(const ChannelParameters&) = delete;
+ ChannelParameters(ChannelParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelParameters)); }
+ ChannelParameters(LDKChannelParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelParameters)); }
+ operator LDKChannelParameters() && { LDKChannelParameters res = self; memset(&self, 0, sizeof(LDKChannelParameters)); return res; }
+ ~ChannelParameters() { ChannelParameters_free(self); }
+ ChannelParameters& operator=(ChannelParameters&& o) { ChannelParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelParameters)); return *this; }
+ LDKChannelParameters* operator &() { return &self; }
+ LDKChannelParameters* operator ->() { return &self; }
+ const LDKChannelParameters* operator &() const { return &self; }
+ const LDKChannelParameters* operator ->() const { return &self; }
+};
+class OpenChannel {
+private:
+ LDKOpenChannel self;
+public:
+ OpenChannel(const OpenChannel&) = delete;
+ OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
+ OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
+ operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
+ ~OpenChannel() { OpenChannel_free(self); }
+ OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
+ LDKOpenChannel* operator &() { return &self; }
+ LDKOpenChannel* operator ->() { return &self; }
+ const LDKOpenChannel* operator &() const { return &self; }
+ const LDKOpenChannel* operator ->() const { return &self; }
+};
+class OpenChannelV2 {
+private:
+ LDKOpenChannelV2 self;
+public:
+ OpenChannelV2(const OpenChannelV2&) = delete;
+ OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
+ OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
+ operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
+ ~OpenChannelV2() { OpenChannelV2_free(self); }
+ OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
+ LDKOpenChannelV2* operator &() { return &self; }
+ LDKOpenChannelV2* operator ->() { return &self; }
+ const LDKOpenChannelV2* operator &() const { return &self; }
+ const LDKOpenChannelV2* operator ->() const { return &self; }
+};
+class CommonAcceptChannelFields {
+private:
+ LDKCommonAcceptChannelFields self;
+public:
+ CommonAcceptChannelFields(const CommonAcceptChannelFields&) = delete;
+ CommonAcceptChannelFields(CommonAcceptChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonAcceptChannelFields)); }
+ CommonAcceptChannelFields(LDKCommonAcceptChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonAcceptChannelFields)); }
+ operator LDKCommonAcceptChannelFields() && { LDKCommonAcceptChannelFields res = self; memset(&self, 0, sizeof(LDKCommonAcceptChannelFields)); return res; }
+ ~CommonAcceptChannelFields() { CommonAcceptChannelFields_free(self); }
+ CommonAcceptChannelFields& operator=(CommonAcceptChannelFields&& o) { CommonAcceptChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonAcceptChannelFields)); return *this; }
+ LDKCommonAcceptChannelFields* operator &() { return &self; }
+ LDKCommonAcceptChannelFields* operator ->() { return &self; }
+ const LDKCommonAcceptChannelFields* operator &() const { return &self; }
+ const LDKCommonAcceptChannelFields* operator ->() const { return &self; }
+};
+class AcceptChannel {
+private:
+ LDKAcceptChannel self;
+public:
+ AcceptChannel(const AcceptChannel&) = delete;
+ AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
+ AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
+ operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
+ ~AcceptChannel() { AcceptChannel_free(self); }
+ AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
+ LDKAcceptChannel* operator &() { return &self; }
+ LDKAcceptChannel* operator ->() { return &self; }
+ const LDKAcceptChannel* operator &() const { return &self; }
+ const LDKAcceptChannel* operator ->() const { return &self; }
+};
+class AcceptChannelV2 {
+private:
+ LDKAcceptChannelV2 self;
+public:
+ AcceptChannelV2(const AcceptChannelV2&) = delete;
+ AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
+ AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
+ operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
+ ~AcceptChannelV2() { AcceptChannelV2_free(self); }
+ AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
+ LDKAcceptChannelV2* operator &() { return &self; }
+ LDKAcceptChannelV2* operator ->() { return &self; }
+ const LDKAcceptChannelV2* operator &() const { return &self; }
+ const LDKAcceptChannelV2* operator ->() const { return &self; }
+};
+class FundingCreated {
+private:
+ LDKFundingCreated self;
+public:
+ FundingCreated(const FundingCreated&) = delete;
+ FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
+ FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
+ operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
+ ~FundingCreated() { FundingCreated_free(self); }
+ FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
+ LDKFundingCreated* operator &() { return &self; }
+ LDKFundingCreated* operator ->() { return &self; }
+ const LDKFundingCreated* operator &() const { return &self; }
+ const LDKFundingCreated* operator ->() const { return &self; }
+};
+class FundingSigned {
+private:
+ LDKFundingSigned self;
+public:
+ FundingSigned(const FundingSigned&) = delete;
+ FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
+ FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
+ operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
+ ~FundingSigned() { FundingSigned_free(self); }
+ FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
+ LDKFundingSigned* operator &() { return &self; }
+ LDKFundingSigned* operator ->() { return &self; }
+ const LDKFundingSigned* operator &() const { return &self; }
+ const LDKFundingSigned* operator ->() const { return &self; }
+};
+class ChannelReady {
+private:
+ LDKChannelReady self;
+public:
+ ChannelReady(const ChannelReady&) = delete;
+ ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
+ ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
+ operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
+ ~ChannelReady() { ChannelReady_free(self); }
+ ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
+ LDKChannelReady* operator &() { return &self; }
+ LDKChannelReady* operator ->() { return &self; }
+ const LDKChannelReady* operator &() const { return &self; }
+ const LDKChannelReady* operator ->() const { return &self; }
+};
+class Stfu {
+private:
+ LDKStfu self;
+public:
+ Stfu(const Stfu&) = delete;
+ Stfu(Stfu&& o) : self(o.self) { memset(&o, 0, sizeof(Stfu)); }
+ Stfu(LDKStfu&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStfu)); }
+ operator LDKStfu() && { LDKStfu res = self; memset(&self, 0, sizeof(LDKStfu)); return res; }
+ ~Stfu() { Stfu_free(self); }
+ Stfu& operator=(Stfu&& o) { Stfu_free(self); self = o.self; memset(&o, 0, sizeof(Stfu)); return *this; }
+ LDKStfu* operator &() { return &self; }
+ LDKStfu* operator ->() { return &self; }
+ const LDKStfu* operator &() const { return &self; }
+ const LDKStfu* operator ->() const { return &self; }
+};
+class SpliceInit {
+private:
+ LDKSpliceInit self;
+public:
+ SpliceInit(const SpliceInit&) = delete;
+ SpliceInit(SpliceInit&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceInit)); }
+ SpliceInit(LDKSpliceInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceInit)); }
+ operator LDKSpliceInit() && { LDKSpliceInit res = self; memset(&self, 0, sizeof(LDKSpliceInit)); return res; }
+ ~SpliceInit() { SpliceInit_free(self); }
+ SpliceInit& operator=(SpliceInit&& o) { SpliceInit_free(self); self = o.self; memset(&o, 0, sizeof(SpliceInit)); return *this; }
+ LDKSpliceInit* operator &() { return &self; }
+ LDKSpliceInit* operator ->() { return &self; }
+ const LDKSpliceInit* operator &() const { return &self; }
+ const LDKSpliceInit* operator ->() const { return &self; }
+};
+class SpliceAck {
+private:
+ LDKSpliceAck self;
+public:
+ SpliceAck(const SpliceAck&) = delete;
+ SpliceAck(SpliceAck&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceAck)); }
+ SpliceAck(LDKSpliceAck&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceAck)); }
+ operator LDKSpliceAck() && { LDKSpliceAck res = self; memset(&self, 0, sizeof(LDKSpliceAck)); return res; }
+ ~SpliceAck() { SpliceAck_free(self); }
+ SpliceAck& operator=(SpliceAck&& o) { SpliceAck_free(self); self = o.self; memset(&o, 0, sizeof(SpliceAck)); return *this; }
+ LDKSpliceAck* operator &() { return &self; }
+ LDKSpliceAck* operator ->() { return &self; }
+ const LDKSpliceAck* operator &() const { return &self; }
+ const LDKSpliceAck* operator ->() const { return &self; }
+};
+class SpliceLocked {
+private:
+ LDKSpliceLocked self;
+public:
+ SpliceLocked(const SpliceLocked&) = delete;
+ SpliceLocked(SpliceLocked&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceLocked)); }
+ SpliceLocked(LDKSpliceLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceLocked)); }
+ operator LDKSpliceLocked() && { LDKSpliceLocked res = self; memset(&self, 0, sizeof(LDKSpliceLocked)); return res; }
+ ~SpliceLocked() { SpliceLocked_free(self); }
+ SpliceLocked& operator=(SpliceLocked&& o) { SpliceLocked_free(self); self = o.self; memset(&o, 0, sizeof(SpliceLocked)); return *this; }
+ LDKSpliceLocked* operator &() { return &self; }
+ LDKSpliceLocked* operator ->() { return &self; }
+ const LDKSpliceLocked* operator &() const { return &self; }
+ const LDKSpliceLocked* operator ->() const { return &self; }
+};
+class TxAddInput {
+private:
+ LDKTxAddInput self;
+public:
+ TxAddInput(const TxAddInput&) = delete;
+ TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
+ TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
+ operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
+ ~TxAddInput() { TxAddInput_free(self); }
+ TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
+ LDKTxAddInput* operator &() { return &self; }
+ LDKTxAddInput* operator ->() { return &self; }
+ const LDKTxAddInput* operator &() const { return &self; }
+ const LDKTxAddInput* operator ->() const { return &self; }
+};
+class TxAddOutput {
+private:
+ LDKTxAddOutput self;
+public:
+ TxAddOutput(const TxAddOutput&) = delete;
+ TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
+ TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
+ operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
+ ~TxAddOutput() { TxAddOutput_free(self); }
+ TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
+ LDKTxAddOutput* operator &() { return &self; }
+ LDKTxAddOutput* operator ->() { return &self; }
+ const LDKTxAddOutput* operator &() const { return &self; }
+ const LDKTxAddOutput* operator ->() const { return &self; }
+};
+class TxRemoveInput {
+private:
+ LDKTxRemoveInput self;
+public:
+ TxRemoveInput(const TxRemoveInput&) = delete;
+ TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
+ TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
+ operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
+ ~TxRemoveInput() { TxRemoveInput_free(self); }
+ TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
+ LDKTxRemoveInput* operator &() { return &self; }
+ LDKTxRemoveInput* operator ->() { return &self; }
+ const LDKTxRemoveInput* operator &() const { return &self; }
+ const LDKTxRemoveInput* operator ->() const { return &self; }
+};
+class TxRemoveOutput {
+private:
+ LDKTxRemoveOutput self;
+public:
+ TxRemoveOutput(const TxRemoveOutput&) = delete;
+ TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
+ TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
+ operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
+ ~TxRemoveOutput() { TxRemoveOutput_free(self); }
+ TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
+ LDKTxRemoveOutput* operator &() { return &self; }
+ LDKTxRemoveOutput* operator ->() { return &self; }
+ const LDKTxRemoveOutput* operator &() const { return &self; }
+ const LDKTxRemoveOutput* operator ->() const { return &self; }
+};
+class TxComplete {
+private:
+ LDKTxComplete self;
+public:
+ TxComplete(const TxComplete&) = delete;
+ TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
+ TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
+ operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
+ ~TxComplete() { TxComplete_free(self); }
+ TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
+ LDKTxComplete* operator &() { return &self; }
+ LDKTxComplete* operator ->() { return &self; }
+ const LDKTxComplete* operator &() const { return &self; }
+ const LDKTxComplete* operator ->() const { return &self; }
+};
+class TxSignatures {
+private:
+ LDKTxSignatures self;
+public:
+ TxSignatures(const TxSignatures&) = delete;
+ TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
+ TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
+ operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
+ ~TxSignatures() { TxSignatures_free(self); }
+ TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
+ LDKTxSignatures* operator &() { return &self; }
+ LDKTxSignatures* operator ->() { return &self; }
+ const LDKTxSignatures* operator &() const { return &self; }
+ const LDKTxSignatures* operator ->() const { return &self; }
+};
+class TxInitRbf {
+private:
+ LDKTxInitRbf self;
+public:
+ TxInitRbf(const TxInitRbf&) = delete;
+ TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
+ TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
+ operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
+ ~TxInitRbf() { TxInitRbf_free(self); }
+ TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
+ LDKTxInitRbf* operator &() { return &self; }
+ LDKTxInitRbf* operator ->() { return &self; }
+ const LDKTxInitRbf* operator &() const { return &self; }
+ const LDKTxInitRbf* operator ->() const { return &self; }
+};
+class TxAckRbf {
+private:
+ LDKTxAckRbf self;
+public:
+ TxAckRbf(const TxAckRbf&) = delete;
+ TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
+ TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
+ operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
+ ~TxAckRbf() { TxAckRbf_free(self); }
+ TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
+ LDKTxAckRbf* operator &() { return &self; }
+ LDKTxAckRbf* operator ->() { return &self; }
+ const LDKTxAckRbf* operator &() const { return &self; }
+ const LDKTxAckRbf* operator ->() const { return &self; }
+};
+class TxAbort {
+private:
+ LDKTxAbort self;
+public:
+ TxAbort(const TxAbort&) = delete;
+ TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
+ TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
+ operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
+ ~TxAbort() { TxAbort_free(self); }
+ TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
+ LDKTxAbort* operator &() { return &self; }
+ LDKTxAbort* operator ->() { return &self; }
+ const LDKTxAbort* operator &() const { return &self; }
+ const LDKTxAbort* operator ->() const { return &self; }
+};
+class Shutdown {
+private:
+ LDKShutdown self;
+public:
+ Shutdown(const Shutdown&) = delete;
+ Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
+ Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
+ operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
+ ~Shutdown() { Shutdown_free(self); }
+ Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
+ LDKShutdown* operator &() { return &self; }
+ LDKShutdown* operator ->() { return &self; }
+ const LDKShutdown* operator &() const { return &self; }
+ const LDKShutdown* operator ->() const { return &self; }
+};
+class ClosingSignedFeeRange {
+private:
+ LDKClosingSignedFeeRange self;
+public:
+ ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
+ ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
+ ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
+ operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
+ ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
+ ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
+ LDKClosingSignedFeeRange* operator &() { return &self; }
+ LDKClosingSignedFeeRange* operator ->() { return &self; }
+ const LDKClosingSignedFeeRange* operator &() const { return &self; }
+ const LDKClosingSignedFeeRange* operator ->() const { return &self; }
+};
+class ClosingSigned {
+private:
+ LDKClosingSigned self;
+public:
+ ClosingSigned(const ClosingSigned&) = delete;
+ ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
+ ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
+ operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
+ ~ClosingSigned() { ClosingSigned_free(self); }
+ ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
+ LDKClosingSigned* operator &() { return &self; }
+ LDKClosingSigned* operator ->() { return &self; }
+ const LDKClosingSigned* operator &() const { return &self; }
+ const LDKClosingSigned* operator ->() const { return &self; }
+};
+class UpdateAddHTLC {
+private:
+ LDKUpdateAddHTLC self;
+public:
+ UpdateAddHTLC(const UpdateAddHTLC&) = delete;
+ UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
+ UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
+ operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
+ ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
+ UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
+ LDKUpdateAddHTLC* operator &() { return &self; }
+ LDKUpdateAddHTLC* operator ->() { return &self; }
+ const LDKUpdateAddHTLC* operator &() const { return &self; }
+ const LDKUpdateAddHTLC* operator ->() const { return &self; }
+};
+class OnionMessage {
+private:
+ LDKOnionMessage self;
+public:
+ OnionMessage(const OnionMessage&) = delete;
+ OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
+ OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
+ operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
+ ~OnionMessage() { OnionMessage_free(self); }
+ OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
+ LDKOnionMessage* operator &() { return &self; }
+ LDKOnionMessage* operator ->() { return &self; }
+ const LDKOnionMessage* operator &() const { return &self; }
+ const LDKOnionMessage* operator ->() const { return &self; }
+};
+class UpdateFulfillHTLC {
+private:
+ LDKUpdateFulfillHTLC self;
+public:
+ UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
+ UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
+ UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
+ operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
+ ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
+ UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
+ LDKUpdateFulfillHTLC* operator &() { return &self; }
+ LDKUpdateFulfillHTLC* operator ->() { return &self; }
+ const LDKUpdateFulfillHTLC* operator &() const { return &self; }
+ const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
+};
+class UpdateFailHTLC {
+private:
+ LDKUpdateFailHTLC self;
+public:
+ UpdateFailHTLC(const UpdateFailHTLC&) = delete;
+ UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
+ UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
+ operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
+ ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
+ UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
+ LDKUpdateFailHTLC* operator &() { return &self; }
+ LDKUpdateFailHTLC* operator ->() { return &self; }
+ const LDKUpdateFailHTLC* operator &() const { return &self; }
+ const LDKUpdateFailHTLC* operator ->() const { return &self; }
+};
+class UpdateFailMalformedHTLC {
+private:
+ LDKUpdateFailMalformedHTLC self;
+public:
+ UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
+ UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
+ UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
+ operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
+ ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
+ UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
+ LDKUpdateFailMalformedHTLC* operator &() { return &self; }
+ LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
+ const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
+ const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
+};
+class CommitmentSignedBatch {
+private:
+ LDKCommitmentSignedBatch self;
+public:
+ CommitmentSignedBatch(const CommitmentSignedBatch&) = delete;
+ CommitmentSignedBatch(CommitmentSignedBatch&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSignedBatch)); }
+ CommitmentSignedBatch(LDKCommitmentSignedBatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSignedBatch)); }
+ operator LDKCommitmentSignedBatch() && { LDKCommitmentSignedBatch res = self; memset(&self, 0, sizeof(LDKCommitmentSignedBatch)); return res; }
+ ~CommitmentSignedBatch() { CommitmentSignedBatch_free(self); }
+ CommitmentSignedBatch& operator=(CommitmentSignedBatch&& o) { CommitmentSignedBatch_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSignedBatch)); return *this; }
+ LDKCommitmentSignedBatch* operator &() { return &self; }
+ LDKCommitmentSignedBatch* operator ->() { return &self; }
+ const LDKCommitmentSignedBatch* operator &() const { return &self; }
+ const LDKCommitmentSignedBatch* operator ->() const { return &self; }
+};
+class CommitmentSigned {
+private:
+ LDKCommitmentSigned self;
+public:
+ CommitmentSigned(const CommitmentSigned&) = delete;
+ CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
+ CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
+ operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
+ ~CommitmentSigned() { CommitmentSigned_free(self); }
+ CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
+ LDKCommitmentSigned* operator &() { return &self; }
+ LDKCommitmentSigned* operator ->() { return &self; }
+ const LDKCommitmentSigned* operator &() const { return &self; }
+ const LDKCommitmentSigned* operator ->() const { return &self; }
+};
+class RevokeAndACK {
+private:
+ LDKRevokeAndACK self;
+public:
+ RevokeAndACK(const RevokeAndACK&) = delete;
+ RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
+ RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
+ operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
+ ~RevokeAndACK() { RevokeAndACK_free(self); }
+ RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
+ LDKRevokeAndACK* operator &() { return &self; }
+ LDKRevokeAndACK* operator ->() { return &self; }
+ const LDKRevokeAndACK* operator &() const { return &self; }
+ const LDKRevokeAndACK* operator ->() const { return &self; }
+};
+class UpdateFee {
+private:
+ LDKUpdateFee self;
+public:
+ UpdateFee(const UpdateFee&) = delete;
+ UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
+ UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
+ operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
+ ~UpdateFee() { UpdateFee_free(self); }
+ UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
+ LDKUpdateFee* operator &() { return &self; }
+ LDKUpdateFee* operator ->() { return &self; }
+ const LDKUpdateFee* operator &() const { return &self; }
+ const LDKUpdateFee* operator ->() const { return &self; }
+};
+class ChannelReestablish {
+private:
+ LDKChannelReestablish self;
+public:
+ ChannelReestablish(const ChannelReestablish&) = delete;
+ ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
+ ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
+ operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
+ ~ChannelReestablish() { ChannelReestablish_free(self); }
+ ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
+ LDKChannelReestablish* operator &() { return &self; }
+ LDKChannelReestablish* operator ->() { return &self; }
+ const LDKChannelReestablish* operator &() const { return &self; }
+ const LDKChannelReestablish* operator ->() const { return &self; }
+};
+class AnnouncementSignatures {
+private:
+ LDKAnnouncementSignatures self;
+public:
+ AnnouncementSignatures(const AnnouncementSignatures&) = delete;
+ AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
+ AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
+ operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
+ ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
+ AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
+ LDKAnnouncementSignatures* operator &() { return &self; }
+ LDKAnnouncementSignatures* operator ->() { return &self; }
+ const LDKAnnouncementSignatures* operator &() const { return &self; }
+ const LDKAnnouncementSignatures* operator ->() const { return &self; }
+};
+class SocketAddress {
+private:
+ LDKSocketAddress self;
+public:
+ SocketAddress(const SocketAddress&) = delete;
+ SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
+ SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
+ operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
+ ~SocketAddress() { SocketAddress_free(self); }
+ SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
+ LDKSocketAddress* operator &() { return &self; }
+ LDKSocketAddress* operator ->() { return &self; }
+ const LDKSocketAddress* operator &() const { return &self; }
+ const LDKSocketAddress* operator ->() const { return &self; }
+};
+class SocketAddressParseError {
+private:
+ LDKSocketAddressParseError self;
+public:
+ SocketAddressParseError(const SocketAddressParseError&) = delete;
+ SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
+ SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
+ operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
+ SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
+ LDKSocketAddressParseError* operator &() { return &self; }
+ LDKSocketAddressParseError* operator ->() { return &self; }
+ const LDKSocketAddressParseError* operator &() const { return &self; }
+ const LDKSocketAddressParseError* operator ->() const { return &self; }
+};
+class UnsignedGossipMessage {
+private:
+ LDKUnsignedGossipMessage self;
+public:
+ UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
+ UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
+ UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
+ operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
+ ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
+ UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
+ LDKUnsignedGossipMessage* operator &() { return &self; }
+ LDKUnsignedGossipMessage* operator ->() { return &self; }
+ const LDKUnsignedGossipMessage* operator &() const { return &self; }
+ const LDKUnsignedGossipMessage* operator ->() const { return &self; }
+};
+class UnsignedNodeAnnouncement {
+private:
+ LDKUnsignedNodeAnnouncement self;
+public:
+ UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
+ UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
+ UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
+ operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
+ ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
+ UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
+ LDKUnsignedNodeAnnouncement* operator &() { return &self; }
+ LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
+ const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
+ const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
+};
+class NodeAnnouncement {
+private:
+ LDKNodeAnnouncement self;
+public:
+ NodeAnnouncement(const NodeAnnouncement&) = delete;
+ NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
+ NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
+ operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
+ ~NodeAnnouncement() { NodeAnnouncement_free(self); }
+ NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
+ LDKNodeAnnouncement* operator &() { return &self; }
+ LDKNodeAnnouncement* operator ->() { return &self; }
+ const LDKNodeAnnouncement* operator &() const { return &self; }
+ const LDKNodeAnnouncement* operator ->() const { return &self; }
+};
+class UnsignedChannelAnnouncement {
+private:
+ LDKUnsignedChannelAnnouncement self;
+public:
+ UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
+ UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
+ UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
+ operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
+ ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
+ UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
+ LDKUnsignedChannelAnnouncement* operator &() { return &self; }
+ LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
+ const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
+ const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
+};
+class ChannelAnnouncement {
+private:
+ LDKChannelAnnouncement self;
+public:
+ ChannelAnnouncement(const ChannelAnnouncement&) = delete;
+ ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
+ ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
+ operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
+ ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
+ ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
+ LDKChannelAnnouncement* operator &() { return &self; }
+ LDKChannelAnnouncement* operator ->() { return &self; }
+ const LDKChannelAnnouncement* operator &() const { return &self; }
+ const LDKChannelAnnouncement* operator ->() const { return &self; }
+};
+class UnsignedChannelUpdate {
+private:
+ LDKUnsignedChannelUpdate self;
+public:
+ UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
+ UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
+ UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
+ operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
+ ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
+ UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
+ LDKUnsignedChannelUpdate* operator &() { return &self; }
+ LDKUnsignedChannelUpdate* operator ->() { return &self; }
+ const LDKUnsignedChannelUpdate* operator &() const { return &self; }
+ const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
+};
+class ChannelUpdate {
+private:
+ LDKChannelUpdate self;
+public:
+ ChannelUpdate(const ChannelUpdate&) = delete;
+ ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
+ ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
+ operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
+ ~ChannelUpdate() { ChannelUpdate_free(self); }
+ ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
+ LDKChannelUpdate* operator &() { return &self; }
+ LDKChannelUpdate* operator ->() { return &self; }
+ const LDKChannelUpdate* operator &() const { return &self; }
+ const LDKChannelUpdate* operator ->() const { return &self; }
+};
+class QueryChannelRange {
+private:
+ LDKQueryChannelRange self;
+public:
+ QueryChannelRange(const QueryChannelRange&) = delete;
+ QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
+ QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
+ operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
+ ~QueryChannelRange() { QueryChannelRange_free(self); }
+ QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
+ LDKQueryChannelRange* operator &() { return &self; }
+ LDKQueryChannelRange* operator ->() { return &self; }
+ const LDKQueryChannelRange* operator &() const { return &self; }
+ const LDKQueryChannelRange* operator ->() const { return &self; }
+};
+class ReplyChannelRange {
+private:
+ LDKReplyChannelRange self;
+public:
+ ReplyChannelRange(const ReplyChannelRange&) = delete;
+ ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
+ ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
+ operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
+ ~ReplyChannelRange() { ReplyChannelRange_free(self); }
+ ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
+ LDKReplyChannelRange* operator &() { return &self; }
+ LDKReplyChannelRange* operator ->() { return &self; }
+ const LDKReplyChannelRange* operator &() const { return &self; }
+ const LDKReplyChannelRange* operator ->() const { return &self; }
+};
+class QueryShortChannelIds {
+private:
+ LDKQueryShortChannelIds self;
+public:
+ QueryShortChannelIds(const QueryShortChannelIds&) = delete;
+ QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
+ QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
+ operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
+ ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
+ QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
+ LDKQueryShortChannelIds* operator &() { return &self; }
+ LDKQueryShortChannelIds* operator ->() { return &self; }
+ const LDKQueryShortChannelIds* operator &() const { return &self; }
+ const LDKQueryShortChannelIds* operator ->() const { return &self; }
+};
+class ReplyShortChannelIdsEnd {
+private:
+ LDKReplyShortChannelIdsEnd self;
+public:
+ ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
+ ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
+ ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
+ operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
+ ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
+ ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
+ LDKReplyShortChannelIdsEnd* operator &() { return &self; }
+ LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
+ const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
+ const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
+};
+class GossipTimestampFilter {
+private:
+ LDKGossipTimestampFilter self;
+public:
+ GossipTimestampFilter(const GossipTimestampFilter&) = delete;
+ GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
+ GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
+ operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
+ ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
+ GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
+ LDKGossipTimestampFilter* operator &() { return &self; }
+ LDKGossipTimestampFilter* operator ->() { return &self; }
+ const LDKGossipTimestampFilter* operator &() const { return &self; }
+ const LDKGossipTimestampFilter* operator ->() const { return &self; }
+};
+class ErrorAction {
+private:
+ LDKErrorAction self;
+public:
+ ErrorAction(const ErrorAction&) = delete;
+ ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
+ ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
+ operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
+ ~ErrorAction() { ErrorAction_free(self); }
+ ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
+ LDKErrorAction* operator &() { return &self; }
+ LDKErrorAction* operator ->() { return &self; }
+ const LDKErrorAction* operator &() const { return &self; }
+ const LDKErrorAction* operator ->() const { return &self; }
+};
+class LightningError {
+private:
+ LDKLightningError self;
+public:
+ LightningError(const LightningError&) = delete;
+ LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
+ LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
+ operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
+ ~LightningError() { LightningError_free(self); }
+ LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
+ LDKLightningError* operator &() { return &self; }
+ LDKLightningError* operator ->() { return &self; }
+ const LDKLightningError* operator &() const { return &self; }
+ const LDKLightningError* operator ->() const { return &self; }
+};
+class CommitmentUpdate {
+private:
+ LDKCommitmentUpdate self;
+public:
+ CommitmentUpdate(const CommitmentUpdate&) = delete;
+ CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
+ CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
+ operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
+ ~CommitmentUpdate() { CommitmentUpdate_free(self); }
+ CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
+ LDKCommitmentUpdate* operator &() { return &self; }
+ LDKCommitmentUpdate* operator ->() { return &self; }
+ const LDKCommitmentUpdate* operator &() const { return &self; }
+ const LDKCommitmentUpdate* operator ->() const { return &self; }
+};
+class ChannelMessageHandler {
+private:
+ LDKChannelMessageHandler self;
+public:
+ ChannelMessageHandler(const ChannelMessageHandler&) = delete;
+ ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
+ ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
+ operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
+ ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
+ ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
+ LDKChannelMessageHandler* operator &() { return &self; }
+ LDKChannelMessageHandler* operator ->() { return &self; }
+ const LDKChannelMessageHandler* operator &() const { return &self; }
+ const LDKChannelMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `open_channel` message from the given peer.
+ */
+ inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `open_channel2` message from the given peer.
+ */
+ inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `accept_channel` message from the given peer.
+ */
+ inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `accept_channel2` message from the given peer.
+ */
+ inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `funding_created` message from the given peer.
+ */
+ inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `funding_signed` message from the given peer.
+ */
+ inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_ready` message from the given peer.
+ */
+ inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `shutdown` message from the given peer.
+ */
+ inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `closing_signed` message from the given peer.
+ */
+ inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `stfu` message from the given peer.
+ */
+ inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_add_input message` from the given peer.
+ */
+ inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_add_output` message from the given peer.
+ */
+ inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_remove_input` message from the given peer.
+ */
+ inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_remove_output` message from the given peer.
+ */
+ inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_complete message` from the given peer.
+ */
+ inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_signatures` message from the given peer.
+ */
+ inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_init_rbf` message from the given peer.
+ */
+ inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_ack_rbf` message from the given peer.
+ */
+ inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_abort message` from the given peer.
+ */
+ inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_add_htlc` message from the given peer.
+ */
+ inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fulfill_htlc` message from the given peer.
+ */
+ inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fail_htlc` message from the given peer.
+ */
+ inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fail_malformed_htlc` message from the given peer.
+ */
+ inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `commitment_signed` message from the given peer.
+ */
+ inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `revoke_and_ack` message from the given peer.
+ */
+ inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fee` message from the given peer.
+ */
+ inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `announcement_signatures` message from the given peer.
+ */
+ inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
+ /**
+ * Indicates a connection to the peer failed/an existing connection was lost.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
+ /**
+ * Handle an incoming `channel_reestablish` message from the given peer.
+ */
+ inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_update` message from the given peer.
+ */
+ inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `error` message from the given peer.
+ */
+ inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+ /**
+ * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
+ *
+ * If it's `None`, then no particular network chain hash compatibility will be enforced when
+ * connecting to peers.
+ */
+ inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
+};
+class RoutingMessageHandler {
+private:
+ LDKRoutingMessageHandler self;
+public:
+ RoutingMessageHandler(const RoutingMessageHandler&) = delete;
+ RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
+ RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
+ operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
+ ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
+ RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
+ LDKRoutingMessageHandler* operator &() { return &self; }
+ LDKRoutingMessageHandler* operator ->() { return &self; }
+ const LDKRoutingMessageHandler* operator &() const { return &self; }
+ const LDKRoutingMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
+ * `false` or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+ /**
+ * Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
+ * or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_update` message, returning true if it should be forwarded on,
+ * `false` or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
+ /**
+ * Gets channel announcements and updates required to dump our routing table to a remote node,
+ * starting at the `short_channel_id` indicated by `starting_point` and including announcements
+ * for a single channel.
+ */
+ inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
+ /**
+ * Gets a node announcement required to dump our routing table to a remote node, starting at
+ * the node *after* the provided pubkey and including up to one announcement immediately
+ * higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
+ * If `None` is provided for `starting_point`, we start at the first node.
+ *
+ * Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
+ /**
+ * Called when a connection is established with a peer. This can be used to
+ * perform routing table synchronization using a strategy defined by the
+ * implementor.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
+ /**
+ * Handles the reply of a query we initiated to learn about channels
+ * for a given range of blocks. We can expect to receive one or more
+ * replies to a single query.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
+ /**
+ * Handles the reply of a query we initiated asking for routing gossip
+ * messages for a list of channels. We should receive this message when
+ * a node has completed its best effort to send us the pertaining routing
+ * gossip messages.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
+ /**
+ * Handles when a peer asks us to send a list of `short_channel_id`s
+ * for the requested range of blocks.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
+ /**
+ * Handles when a peer asks us to send routing gossip messages for a
+ * list of `short_channel_id`s.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
+ /**
+ * Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
+ * pending some async action. While there is no guarantee of the rate of future messages, the
+ * caller should seek to reduce the rate of new gossip messages handled, especially
+ * [`ChannelAnnouncement`]s.
+ */
+ inline bool processing_queue_high();
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class OnionMessageHandler {
+private:
+ LDKOnionMessageHandler self;
+public:
+ OnionMessageHandler(const OnionMessageHandler&) = delete;
+ OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
+ OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
+ operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
+ ~OnionMessageHandler() { OnionMessageHandler_free(self); }
+ OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
+ LDKOnionMessageHandler* operator &() { return &self; }
+ LDKOnionMessageHandler* operator ->() { return &self; }
+ const LDKOnionMessageHandler* operator &() const { return &self; }
+ const LDKOnionMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `onion_message` message from the given peer.
+ */
+ inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
+ /**
+ * Returns the next pending onion message for the peer with the given node id.
+ *
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
+ /**
+ * Called when a connection is established with a peer. Can be used to track which peers
+ * advertise onion message support and are online.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
+ /**
+ * Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
+ * drop and refuse to forward onion messages to this peer.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Performs actions that should happen roughly every ten seconds after startup. Allows handlers
+ * to drop any buffered onion messages intended for prospective peers.
+ */
+ inline void timer_tick_occurred();
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class FinalOnionHopData {
+private:
+ LDKFinalOnionHopData self;
+public:
+ FinalOnionHopData(const FinalOnionHopData&) = delete;
+ FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
+ FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
+ operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
+ ~FinalOnionHopData() { FinalOnionHopData_free(self); }
+ FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
+ LDKFinalOnionHopData* operator &() { return &self; }
+ LDKFinalOnionHopData* operator ->() { return &self; }
+ const LDKFinalOnionHopData* operator &() const { return &self; }
+ const LDKFinalOnionHopData* operator ->() const { return &self; }
+};
+class OnionPacket {
+private:
+ LDKOnionPacket self;
+public:
+ OnionPacket(const OnionPacket&) = delete;
+ OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
+ OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
+ operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
+ ~OnionPacket() { OnionPacket_free(self); }
+ OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
+ LDKOnionPacket* operator &() { return &self; }
+ LDKOnionPacket* operator ->() { return &self; }
+ const LDKOnionPacket* operator &() const { return &self; }
+ const LDKOnionPacket* operator ->() const { return &self; }
+};
+class TrampolineOnionPacket {
+private:
+ LDKTrampolineOnionPacket self;
+public:
+ TrampolineOnionPacket(const TrampolineOnionPacket&) = delete;
+ TrampolineOnionPacket(TrampolineOnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(TrampolineOnionPacket)); }
+ TrampolineOnionPacket(LDKTrampolineOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrampolineOnionPacket)); }
+ operator LDKTrampolineOnionPacket() && { LDKTrampolineOnionPacket res = self; memset(&self, 0, sizeof(LDKTrampolineOnionPacket)); return res; }
+ ~TrampolineOnionPacket() { TrampolineOnionPacket_free(self); }
+ TrampolineOnionPacket& operator=(TrampolineOnionPacket&& o) { TrampolineOnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(TrampolineOnionPacket)); return *this; }
+ LDKTrampolineOnionPacket* operator &() { return &self; }
+ LDKTrampolineOnionPacket* operator ->() { return &self; }
+ const LDKTrampolineOnionPacket* operator &() const { return &self; }
+ const LDKTrampolineOnionPacket* operator ->() const { return &self; }
+};
+class Level {
+private:
+ LDKLevel self;
+public:
+ Level(const Level&) = delete;
+ Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
+ Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
+ operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
+ Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
+ LDKLevel* operator &() { return &self; }
+ LDKLevel* operator ->() { return &self; }
+ const LDKLevel* operator &() const { return &self; }
+ const LDKLevel* operator ->() const { return &self; }
+};
+class Record {
+private:
+ LDKRecord self;
+public:
+ Record(const Record&) = delete;
+ Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
+ Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
+ operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
+ ~Record() { Record_free(self); }
+ Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
+ LDKRecord* operator &() { return &self; }
+ LDKRecord* operator ->() { return &self; }
+ const LDKRecord* operator &() const { return &self; }
+ const LDKRecord* operator ->() const { return &self; }
+};
+class Logger {
+private:
+ LDKLogger self;
+public:
+ Logger(const Logger&) = delete;
+ Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
+ Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
+ operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
+ ~Logger() { Logger_free(self); }
+ Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
+ LDKLogger* operator &() { return &self; }
+ LDKLogger* operator ->() { return &self; }
+ const LDKLogger* operator &() const { return &self; }
+ const LDKLogger* operator ->() const { return &self; }
+ /**
+ * Logs the [`Record`].
+ */
+ inline void log(struct LDKRecord record);
+};
+class InboundHTLCStateDetails {
+private:
+ LDKInboundHTLCStateDetails self;
+public:
+ InboundHTLCStateDetails(const InboundHTLCStateDetails&) = delete;
+ InboundHTLCStateDetails(InboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCStateDetails)); }
+ InboundHTLCStateDetails(LDKInboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCStateDetails)); }
+ operator LDKInboundHTLCStateDetails() && { LDKInboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCStateDetails)); return res; }
+ InboundHTLCStateDetails& operator=(InboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(InboundHTLCStateDetails)); return *this; }
+ LDKInboundHTLCStateDetails* operator &() { return &self; }
+ LDKInboundHTLCStateDetails* operator ->() { return &self; }
+ const LDKInboundHTLCStateDetails* operator &() const { return &self; }
+ const LDKInboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class InboundHTLCDetails {
+private:
+ LDKInboundHTLCDetails self;
+public:
+ InboundHTLCDetails(const InboundHTLCDetails&) = delete;
+ InboundHTLCDetails(InboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCDetails)); }
+ InboundHTLCDetails(LDKInboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCDetails)); }
+ operator LDKInboundHTLCDetails() && { LDKInboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCDetails)); return res; }
+ ~InboundHTLCDetails() { InboundHTLCDetails_free(self); }
+ InboundHTLCDetails& operator=(InboundHTLCDetails&& o) { InboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCDetails)); return *this; }
+ LDKInboundHTLCDetails* operator &() { return &self; }
+ LDKInboundHTLCDetails* operator ->() { return &self; }
+ const LDKInboundHTLCDetails* operator &() const { return &self; }
+ const LDKInboundHTLCDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCStateDetails {
+private:
+ LDKOutboundHTLCStateDetails self;
+public:
+ OutboundHTLCStateDetails(const OutboundHTLCStateDetails&) = delete;
+ OutboundHTLCStateDetails(OutboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCStateDetails)); }
+ OutboundHTLCStateDetails(LDKOutboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCStateDetails)); }
+ operator LDKOutboundHTLCStateDetails() && { LDKOutboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCStateDetails)); return res; }
+ OutboundHTLCStateDetails& operator=(OutboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(OutboundHTLCStateDetails)); return *this; }
+ LDKOutboundHTLCStateDetails* operator &() { return &self; }
+ LDKOutboundHTLCStateDetails* operator ->() { return &self; }
+ const LDKOutboundHTLCStateDetails* operator &() const { return &self; }
+ const LDKOutboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCDetails {
+private:
+ LDKOutboundHTLCDetails self;
+public:
+ OutboundHTLCDetails(const OutboundHTLCDetails&) = delete;
+ OutboundHTLCDetails(OutboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCDetails)); }
+ OutboundHTLCDetails(LDKOutboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCDetails)); }
+ operator LDKOutboundHTLCDetails() && { LDKOutboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCDetails)); return res; }
+ ~OutboundHTLCDetails() { OutboundHTLCDetails_free(self); }
+ OutboundHTLCDetails& operator=(OutboundHTLCDetails&& o) { OutboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(OutboundHTLCDetails)); return *this; }
+ LDKOutboundHTLCDetails* operator &() { return &self; }
+ LDKOutboundHTLCDetails* operator ->() { return &self; }
+ const LDKOutboundHTLCDetails* operator &() const { return &self; }
+ const LDKOutboundHTLCDetails* operator ->() const { return &self; }
+};
+class CounterpartyForwardingInfo {
+private:
+ LDKCounterpartyForwardingInfo self;
+public:
+ CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
+ CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
+ CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
+ operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
+ ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
+ CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
+ LDKCounterpartyForwardingInfo* operator &() { return &self; }
+ LDKCounterpartyForwardingInfo* operator ->() { return &self; }
+ const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
+ const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
+};
+class ChannelCounterparty {
+private:
+ LDKChannelCounterparty self;
+public:
+ ChannelCounterparty(const ChannelCounterparty&) = delete;
+ ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
+ ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
+ operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
+ ~ChannelCounterparty() { ChannelCounterparty_free(self); }
+ ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
+ LDKChannelCounterparty* operator &() { return &self; }
+ LDKChannelCounterparty* operator ->() { return &self; }
+ const LDKChannelCounterparty* operator &() const { return &self; }
+ const LDKChannelCounterparty* operator ->() const { return &self; }
+};
+class ChannelDetails {
+private:
+ LDKChannelDetails self;
+public:
+ ChannelDetails(const ChannelDetails&) = delete;
+ ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
+ ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
+ operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
+ ~ChannelDetails() { ChannelDetails_free(self); }
+ ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
+ LDKChannelDetails* operator &() { return &self; }
+ LDKChannelDetails* operator ->() { return &self; }
+ const LDKChannelDetails* operator &() const { return &self; }
+ const LDKChannelDetails* operator ->() const { return &self; }
+};
+class ChannelShutdownState {
+private:
+ LDKChannelShutdownState self;
+public:
+ ChannelShutdownState(const ChannelShutdownState&) = delete;
+ ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
+ ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
+ operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
+ ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
+ LDKChannelShutdownState* operator &() { return &self; }
+ LDKChannelShutdownState* operator ->() { return &self; }
+ const LDKChannelShutdownState* operator &() const { return &self; }
+ const LDKChannelShutdownState* operator ->() const { return &self; }
+};
+class FutureCallback {
+private:
+ LDKFutureCallback self;
+public:
+ FutureCallback(const FutureCallback&) = delete;
+ FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
+ FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
+ operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
+ ~FutureCallback() { FutureCallback_free(self); }
+ FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
+ LDKFutureCallback* operator &() { return &self; }
+ LDKFutureCallback* operator ->() { return &self; }
+ const LDKFutureCallback* operator &() const { return &self; }
+ const LDKFutureCallback* operator ->() const { return &self; }
+ /**
+ * The method which is called.
+ */
+ inline void call();
+};
+class Future {
+private:
+ LDKFuture self;
+public:
+ Future(const Future&) = delete;
+ Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
+ Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
+ operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
+ ~Future() { Future_free(self); }
+ Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
+ LDKFuture* operator &() { return &self; }
+ LDKFuture* operator ->() { return &self; }
+ const LDKFuture* operator &() const { return &self; }
+ const LDKFuture* operator ->() const { return &self; }
+};
+class Sleeper {
+private:
+ LDKSleeper self;
+public:
+ Sleeper(const Sleeper&) = delete;
+ Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
+ Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
+ operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
+ ~Sleeper() { Sleeper_free(self); }
+ Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
+ LDKSleeper* operator &() { return &self; }
+ LDKSleeper* operator ->() { return &self; }
+ const LDKSleeper* operator &() const { return &self; }
+ const LDKSleeper* operator ->() const { return &self; }
+};
+class AsyncPaymentsMessageHandler {
+private:
+ LDKAsyncPaymentsMessageHandler self;
+public:
+ AsyncPaymentsMessageHandler(const AsyncPaymentsMessageHandler&) = delete;
+ AsyncPaymentsMessageHandler(AsyncPaymentsMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); }
+ AsyncPaymentsMessageHandler(LDKAsyncPaymentsMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); }
+ operator LDKAsyncPaymentsMessageHandler() && { LDKAsyncPaymentsMessageHandler res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); return res; }
+ ~AsyncPaymentsMessageHandler() { AsyncPaymentsMessageHandler_free(self); }
+ AsyncPaymentsMessageHandler& operator=(AsyncPaymentsMessageHandler&& o) { AsyncPaymentsMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); return *this; }
+ LDKAsyncPaymentsMessageHandler* operator &() { return &self; }
+ LDKAsyncPaymentsMessageHandler* operator ->() { return &self; }
+ const LDKAsyncPaymentsMessageHandler* operator &() const { return &self; }
+ const LDKAsyncPaymentsMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle a [`HeldHtlcAvailable`] message. A [`ReleaseHeldHtlc`] should be returned to release
+ * the held funds.
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ held_htlc_available(struct LDKHeldHtlcAvailable message, struct LDKResponder responder);
+ /**
+ * Handle a [`ReleaseHeldHtlc`] message. If authentication of the message succeeds, an HTLC
+ * should be released to the corresponding payee.
+ */
+ inline void release_held_htlc(struct LDKReleaseHeldHtlc message);
+ /**
+ * Release any [`AsyncPaymentsMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating an async payment flow rather than in response
+ * to another message.
+ */
+ inline LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class AsyncPaymentsMessage {
+private:
+ LDKAsyncPaymentsMessage self;
+public:
+ AsyncPaymentsMessage(const AsyncPaymentsMessage&) = delete;
+ AsyncPaymentsMessage(AsyncPaymentsMessage&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessage)); }
+ AsyncPaymentsMessage(LDKAsyncPaymentsMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessage)); }
+ operator LDKAsyncPaymentsMessage() && { LDKAsyncPaymentsMessage res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessage)); return res; }
+ ~AsyncPaymentsMessage() { AsyncPaymentsMessage_free(self); }
+ AsyncPaymentsMessage& operator=(AsyncPaymentsMessage&& o) { AsyncPaymentsMessage_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessage)); return *this; }
+ LDKAsyncPaymentsMessage* operator &() { return &self; }
+ LDKAsyncPaymentsMessage* operator ->() { return &self; }
+ const LDKAsyncPaymentsMessage* operator &() const { return &self; }
+ const LDKAsyncPaymentsMessage* operator ->() const { return &self; }
+};
+class HeldHtlcAvailable {
+private:
+ LDKHeldHtlcAvailable self;
+public:
+ HeldHtlcAvailable(const HeldHtlcAvailable&) = delete;
+ HeldHtlcAvailable(HeldHtlcAvailable&& o) : self(o.self) { memset(&o, 0, sizeof(HeldHtlcAvailable)); }
+ HeldHtlcAvailable(LDKHeldHtlcAvailable&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHeldHtlcAvailable)); }
+ operator LDKHeldHtlcAvailable() && { LDKHeldHtlcAvailable res = self; memset(&self, 0, sizeof(LDKHeldHtlcAvailable)); return res; }
+ ~HeldHtlcAvailable() { HeldHtlcAvailable_free(self); }
+ HeldHtlcAvailable& operator=(HeldHtlcAvailable&& o) { HeldHtlcAvailable_free(self); self = o.self; memset(&o, 0, sizeof(HeldHtlcAvailable)); return *this; }
+ LDKHeldHtlcAvailable* operator &() { return &self; }
+ LDKHeldHtlcAvailable* operator ->() { return &self; }
+ const LDKHeldHtlcAvailable* operator &() const { return &self; }
+ const LDKHeldHtlcAvailable* operator ->() const { return &self; }
+};
+class ReleaseHeldHtlc {
+private:
+ LDKReleaseHeldHtlc self;
+public:
+ ReleaseHeldHtlc(const ReleaseHeldHtlc&) = delete;
+ ReleaseHeldHtlc(ReleaseHeldHtlc&& o) : self(o.self) { memset(&o, 0, sizeof(ReleaseHeldHtlc)); }
+ ReleaseHeldHtlc(LDKReleaseHeldHtlc&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReleaseHeldHtlc)); }
+ operator LDKReleaseHeldHtlc() && { LDKReleaseHeldHtlc res = self; memset(&self, 0, sizeof(LDKReleaseHeldHtlc)); return res; }
+ ~ReleaseHeldHtlc() { ReleaseHeldHtlc_free(self); }
+ ReleaseHeldHtlc& operator=(ReleaseHeldHtlc&& o) { ReleaseHeldHtlc_free(self); self = o.self; memset(&o, 0, sizeof(ReleaseHeldHtlc)); return *this; }
+ LDKReleaseHeldHtlc* operator &() { return &self; }
+ LDKReleaseHeldHtlc* operator ->() { return &self; }
+ const LDKReleaseHeldHtlc* operator &() const { return &self; }
+ const LDKReleaseHeldHtlc* operator ->() const { return &self; }
+};
+class OffersMessageHandler {
+private:
+ LDKOffersMessageHandler self;
+public:
+ OffersMessageHandler(const OffersMessageHandler&) = delete;
+ OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
+ OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
+ operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
+ ~OffersMessageHandler() { OffersMessageHandler_free(self); }
+ OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
+ LDKOffersMessageHandler* operator &() { return &self; }
+ LDKOffersMessageHandler* operator ->() { return &self; }
+ const LDKOffersMessageHandler* operator &() const { return &self; }
+ const LDKOffersMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
+ * or replying with an error.
+ *
+ * The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
+ *
+ * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ handle_message(struct LDKOffersMessage message, struct LDKCOption_OffersContextZ context, struct LDKResponder responder);
+ /**
+ * Releases any [`OffersMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating a payment flow rather than in response to
+ * another message. The latter should use the return value of [`Self::handle_message`].
+ */
+ inline LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class OffersMessage {
+private:
+ LDKOffersMessage self;
+public:
+ OffersMessage(const OffersMessage&) = delete;
+ OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
+ OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
+ operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
+ ~OffersMessage() { OffersMessage_free(self); }
+ OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
+ LDKOffersMessage* operator &() { return &self; }
+ LDKOffersMessage* operator ->() { return &self; }
+ const LDKOffersMessage* operator &() const { return &self; }
+ const LDKOffersMessage* operator ->() const { return &self; }
+};
+class HTLCClaim {
+private:
+ LDKHTLCClaim self;
+public:
+ HTLCClaim(const HTLCClaim&) = delete;
+ HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
+ HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
+ operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
+ HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
+ LDKHTLCClaim* operator &() { return &self; }
+ LDKHTLCClaim* operator ->() { return &self; }
+ const LDKHTLCClaim* operator &() const { return &self; }
+ const LDKHTLCClaim* operator ->() const { return &self; }
+};
+class CounterpartyCommitmentSecrets {
+private:
+ LDKCounterpartyCommitmentSecrets self;
+public:
+ CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
+ CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
+ CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
+ operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
+ ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
+ CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
+ LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
+ LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
+ const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
+ const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
+};
+class TxCreationKeys {
+private:
+ LDKTxCreationKeys self;
+public:
+ TxCreationKeys(const TxCreationKeys&) = delete;
+ TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
+ TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
+ operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
+ ~TxCreationKeys() { TxCreationKeys_free(self); }
+ TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
+ LDKTxCreationKeys* operator &() { return &self; }
+ LDKTxCreationKeys* operator ->() { return &self; }
+ const LDKTxCreationKeys* operator &() const { return &self; }
+ const LDKTxCreationKeys* operator ->() const { return &self; }
+};
+class ChannelPublicKeys {
+private:
+ LDKChannelPublicKeys self;
+public:
+ ChannelPublicKeys(const ChannelPublicKeys&) = delete;
+ ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
+ ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
+ operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
+ ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }