#include <string.h>
namespace LDK {
// Forward declarations
+class Str;
class TxCreationKeys;
class ChannelPublicKeys;
class HTLCOutputInCommitment;
class DirectedChannelTransactionParameters;
class HolderCommitmentTransaction;
class BuiltCommitmentTransaction;
+class ClosingTransaction;
+class TrustedClosingTransaction;
class CommitmentTransaction;
class TrustedCommitmentTransaction;
class ShutdownScript;
class Access;
class Listen;
class Confirm;
+class ChannelMonitorUpdateErr;
class Watch;
class Filter;
class WatchedOutput;
class PaymentPurpose;
+class ClosureReason;
class Event;
class MessageSendEvent;
class MessageSendEventsProvider;
class EventsProvider;
class EventHandler;
+class Score;
class InitFeatures;
class NodeFeatures;
class ChannelFeatures;
class InvoiceFeatures;
+class Scorer;
class DelayedPaymentOutputDescriptor;
class StaticPaymentOutputDescriptor;
class SpendableOutputDescriptor;
class InMemorySigner;
class KeysManager;
class FilesystemPersister;
+class PaymentId;
class ChannelManager;
class ChainParameters;
+class CounterpartyForwardingInfo;
class ChannelCounterparty;
class ChannelDetails;
class PaymentSendFailure;
class UserConfig;
class APIError;
class OutPoint;
+class CustomMessageReader;
+class Type;
class Invoice;
class SignedRawInvoice;
class RawInvoice;
class SemanticError;
class SignOrCreationError;
class ChannelMonitorUpdate;
-class ChannelMonitorUpdateErr;
class MonitorUpdateError;
class MonitorEvent;
class HTLCUpdate;
+class Balance;
class ChannelMonitor;
-class Persist;
+class CustomMessageHandler;
class IgnoringMessageHandler;
class ErroringMessageHandler;
class MessageHandler;
class SocketDescriptor;
class PeerHandleError;
class PeerManager;
+class NodeId;
class NetworkGraph;
-class LockedNetworkGraph;
+class ReadOnlyNetworkGraph;
+class NetworkUpdate;
class NetGraphMsgHandler;
class DirectionalChannelInfo;
class ChannelInfo;
class ErrorAction;
class LightningError;
class CommitmentUpdate;
-class HTLCFailChannelUpdate;
class ChannelMessageHandler;
class RoutingMessageHandler;
class Level;
class Logger;
+class Persist;
+class LockedChannelMonitor;
class ChainMonitor;
class CVec_SpendableOutputDescriptorZ;
+class CResult_LockedChannelMonitorNoneZ;
class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
class CResult_HTLCUpdateDecodeErrorZ;
class CResult_ChannelInfoDecodeErrorZ;
class CResult_FundingCreatedDecodeErrorZ;
class CResult_ChannelAnnouncementDecodeErrorZ;
+class CVec_OutPointZ;
class CResult_PositiveTimestampCreationErrorZ;
class CResult_CVec_u8ZPeerHandleErrorZ;
class CResult_InvoiceFeaturesDecodeErrorZ;
-class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class COption_NetworkUpdateZ;
class COption_u64Z;
class CResult_TxOutAccessErrorZ;
+class CResult_TrustedClosingTransactionNoneZ;
+class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class C2Tuple_PublicKeyTypeZ;
class CResult_NetAddressDecodeErrorZ;
+class CResult_ChannelReestablishDecodeErrorZ;
class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
class CResult_ReplyChannelRangeDecodeErrorZ;
-class CResult_ChannelReestablishDecodeErrorZ;
-class CResult_GossipTimestampFilterDecodeErrorZ;
-class CResult_InvoiceSignOrCreationErrorZ;
class CResult_CommitmentSignedDecodeErrorZ;
class CVec_UpdateAddHTLCZ;
+class CResult_GossipTimestampFilterDecodeErrorZ;
class COption_u32Z;
class CResult_InitFeaturesDecodeErrorZ;
class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
+class CResult_PaymentIdPaymentSendFailureZ;
+class CResult_InvoiceSignOrCreationErrorZ;
class CResult_CommitmentTransactionDecodeErrorZ;
class COption_C2Tuple_usizeTransactionZZ;
class CResult_TransactionNoneZ;
class CResult_ExpiryTimeCreationErrorZ;
class CResult_ClosingSignedFeeRangeDecodeErrorZ;
class CResult_PingDecodeErrorZ;
+class COption_FilterZ;
class CVec_TransactionOutputsZ;
class CResult_ErrorMessageDecodeErrorZ;
class CResult_OpenChannelDecodeErrorZ;
class CResult_ShutdownScriptDecodeErrorZ;
class CResult_InvoiceNoneZ;
class CResult_QueryChannelRangeDecodeErrorZ;
-class C2Tuple_usizeTransactionZ;
class CResult_TxCreationKeysDecodeErrorZ;
+class C2Tuple_usizeTransactionZ;
class CResult_ChannelFeaturesDecodeErrorZ;
class CVec_ChannelMonitorZ;
class CVec_TransactionZ;
class CResult_UpdateFeeDecodeErrorZ;
class CResult_RouteHopDecodeErrorZ;
class CResult_NodeAnnouncementDecodeErrorZ;
+class CVec_BalanceZ;
class CResult_HTLCOutputInCommitmentDecodeErrorZ;
class CResult_boolLightningErrorZ;
class CResult_TxCreationKeysErrorZ;
class C2Tuple_BlockHashChannelMonitorZ;
-class CResult_FundingSignedDecodeErrorZ;
+class CResult_NodeIdDecodeErrorZ;
class CResult_ShutdownScriptInvalidShutdownScriptZ;
class CResult_RecoverableSignatureNoneZ;
class CResult_NodeAnnouncementInfoDecodeErrorZ;
class CResult_NetAddressu8Z;
class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
class CVec_UpdateFailMalformedHTLCZ;
+class CResult_FundingSignedDecodeErrorZ;
class CResult_NetworkGraphDecodeErrorZ;
class CVec_RouteHopZ;
class CVec_C2Tuple_BlockHashChannelMonitorZZ;
class CResult_SignDecodeErrorZ;
class CVec_MessageSendEventZ;
class C2Tuple_OutPointScriptZ;
+class CResult_PaymentIdDecodeErrorZ;
class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
class CVec_NodeAnnouncementZ;
class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
class CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
class CResult_CVec_CVec_u8ZZNoneZ;
class C2Tuple_PaymentHashPaymentSecretZ;
-class CResult_AcceptChannelDecodeErrorZ;
+class COption_AccessZ;
class C2Tuple_BlockHashChannelManagerZ;
class CResult_ChannelTransactionParametersDecodeErrorZ;
-class CResult_PongDecodeErrorZ;
+class CResult_AcceptChannelDecodeErrorZ;
class CVec_SignatureZ;
class CVec_u64Z;
+class CResult_PongDecodeErrorZ;
class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
+class C2Tuple_PaymentHashPaymentIdZ;
class CResult_StringErrorZ;
class CResult_NoneErrorZ;
class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
+class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
class CVec_RouteHintZ;
class COption_u16Z;
class CVec_CVec_RouteHopZZ;
class CResult_TrustedCommitmentTransactionNoneZ;
class CResult_NoneLightningErrorZ;
class CResult_NonePeerHandleErrorZ;
+class COption_CVec_NetAddressZZ;
class CResult_CVec_SignatureZNoneZ;
+class CResult__u832APIErrorZ;
class CResult_DescriptionCreationErrorZ;
+class CVec_C2Tuple_PublicKeyTypeZZ;
class CResult_RoutingFeesDecodeErrorZ;
class CResult_PayeePubKeyErrorZ;
class CResult_QueryShortChannelIdsDecodeErrorZ;
class CVec_NetAddressZ;
class CVec_C2Tuple_usizeTransactionZZ;
class CVec_PublicKeyZ;
+class COption_TypeZ;
+class CResult_COption_TypeZDecodeErrorZ;
class CResult_DirectionalChannelInfoDecodeErrorZ;
class C2Tuple_u32TxOutZ;
class CResult_UpdateFailHTLCDecodeErrorZ;
class CVec_MonitorEventZ;
class CVec_C2Tuple_u32ScriptZZ;
class CResult_NoneChannelMonitorUpdateErrZ;
-class CResult_PaymentHashPaymentSendFailureZ;
class CResult_SiPrefixNoneZ;
class CResult_PublicKeyErrorZ;
class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
+class CResult_NoneNoneZ;
class CResult_PrivateRouteCreationErrorZ;
class CResult_boolPeerHandleErrorZ;
-class CResult_ChannelUpdateDecodeErrorZ;
class CVec_APIErrorZ;
+class CResult_ChannelUpdateDecodeErrorZ;
class CVec_UpdateFulfillHTLCZ;
class CResult_AnnouncementSignaturesDecodeErrorZ;
class CResult_UpdateFulfillHTLCDecodeErrorZ;
class CVec_UpdateFailHTLCZ;
class CResult_FundingLockedDecodeErrorZ;
+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 TxCreationKeys {
private:
LDKTxCreationKeys self;
const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
};
+class ClosingTransaction {
+private:
+ LDKClosingTransaction self;
+public:
+ ClosingTransaction(const ClosingTransaction&) = delete;
+ ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
+ ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
+ operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
+ ~ClosingTransaction() { ClosingTransaction_free(self); }
+ ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
+ LDKClosingTransaction* operator &() { return &self; }
+ LDKClosingTransaction* operator ->() { return &self; }
+ const LDKClosingTransaction* operator &() const { return &self; }
+ const LDKClosingTransaction* operator ->() const { return &self; }
+};
+class TrustedClosingTransaction {
+private:
+ LDKTrustedClosingTransaction self;
+public:
+ TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
+ TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
+ TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
+ operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
+ ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
+ TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
+ LDKTrustedClosingTransaction* operator &() { return &self; }
+ LDKTrustedClosingTransaction* operator ->() { return &self; }
+ const LDKTrustedClosingTransaction* operator &() const { return &self; }
+ const LDKTrustedClosingTransaction* operator ->() const { return &self; }
+};
class CommitmentTransaction {
private:
LDKCommitmentTransaction self;
*/
inline LDK::CVec_TxidZ get_relevant_txids();
};
+class ChannelMonitorUpdateErr {
+private:
+ LDKChannelMonitorUpdateErr self;
+public:
+ ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
+ ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
+ ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
+ operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
+ ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
+ LDKChannelMonitorUpdateErr* operator &() { return &self; }
+ LDKChannelMonitorUpdateErr* operator ->() { return &self; }
+ const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
+ const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
+};
class Watch {
private:
LDKWatch self;
* with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
* calling [`block_connected`] and [`block_disconnected`] on the monitor.
*
+ * Note: this interface MUST error with `ChannelMonitorUpdateErr::PermanentFailure` if
+ * the given `funding_txo` has previously been registered via `watch_channel`.
+ *
* [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
* [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
* [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
* [`ChannelMonitorUpdateErr`] for invariants around returning an error.
*
* [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
- * [`ChannelMonitorUpdateErr`]: channelmonitor::ChannelMonitorUpdateErr
*/
inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
/**
const LDKPaymentPurpose* operator &() const { return &self; }
const LDKPaymentPurpose* operator ->() const { return &self; }
};
+class ClosureReason {
+private:
+ LDKClosureReason self;
+public:
+ ClosureReason(const ClosureReason&) = delete;
+ ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
+ ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
+ operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
+ ~ClosureReason() { ClosureReason_free(self); }
+ ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
+ LDKClosureReason* operator &() { return &self; }
+ LDKClosureReason* operator ->() { return &self; }
+ const LDKClosureReason* operator &() const { return &self; }
+ const LDKClosureReason* operator ->() const { return &self; }
+};
class Event {
private:
LDKEvent self;
*
* See [`EventsProvider`] for details that must be considered when implementing this method.
*/
- inline void handle_event(struct LDKEvent event);
+ inline void handle_event(const struct LDKEvent *NONNULL_PTR event);
+};
+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; }
+ /**
+ * Returns the fee in msats willing to be paid to avoid routing through the given channel.
+ */
+ inline uint64_t channel_penalty_msat(uint64_t short_channel_id);
};
class InitFeatures {
private:
const LDKInvoiceFeatures* operator &() const { return &self; }
const LDKInvoiceFeatures* operator ->() const { return &self; }
};
+class Scorer {
+private:
+ LDKScorer self;
+public:
+ Scorer(const Scorer&) = delete;
+ Scorer(Scorer&& o) : self(o.self) { memset(&o, 0, sizeof(Scorer)); }
+ Scorer(LDKScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorer)); }
+ operator LDKScorer() && { LDKScorer res = self; memset(&self, 0, sizeof(LDKScorer)); return res; }
+ ~Scorer() { Scorer_free(self); }
+ Scorer& operator=(Scorer&& o) { Scorer_free(self); self = o.self; memset(&o, 0, sizeof(Scorer)); return *this; }
+ LDKScorer* operator &() { return &self; }
+ LDKScorer* operator ->() { return &self; }
+ const LDKScorer* operator &() const { return &self; }
+ const LDKScorer* operator ->() const { return &self; }
+};
class DelayedPaymentOutputDescriptor {
private:
LDKDelayedPaymentOutputDescriptor self;
* Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
*/
inline LDKThirtyTwoBytes 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.
+ */
+ inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx);
/**
* Gets 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
* 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.
*/
inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx);
+ /**
+ * 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]);
/**
* Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
* This will only ever be called with a non-revoked commitment_tx. This will be called with the
* 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_SignatureNoneZ sign_closing_transaction(struct LDKTransaction closing_tx);
+ inline LDK::CResult_SignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
/**
* Signs a channel announcement message with our funding key, proving it comes from one
* of the channel participants.
const LDKFilesystemPersister* operator &() const { return &self; }
const LDKFilesystemPersister* operator ->() const { return &self; }
};
+class PaymentId {
+private:
+ LDKPaymentId self;
+public:
+ PaymentId(const PaymentId&) = delete;
+ PaymentId(PaymentId&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentId)); }
+ PaymentId(LDKPaymentId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentId)); }
+ operator LDKPaymentId() && { LDKPaymentId res = self; memset(&self, 0, sizeof(LDKPaymentId)); return res; }
+ ~PaymentId() { PaymentId_free(self); }
+ PaymentId& operator=(PaymentId&& o) { PaymentId_free(self); self = o.self; memset(&o, 0, sizeof(PaymentId)); return *this; }
+ LDKPaymentId* operator &() { return &self; }
+ LDKPaymentId* operator ->() { return &self; }
+ const LDKPaymentId* operator &() const { return &self; }
+ const LDKPaymentId* operator ->() const { return &self; }
+};
class ChannelManager {
private:
LDKChannelManager self;
const LDKChainParameters* operator &() const { return &self; }
const LDKChainParameters* 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;
const LDKOutPoint* operator &() const { return &self; }
const LDKOutPoint* operator ->() const { return &self; }
};
+class CustomMessageReader {
+private:
+ LDKCustomMessageReader self;
+public:
+ CustomMessageReader(const CustomMessageReader&) = delete;
+ CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
+ CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
+ operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
+ ~CustomMessageReader() { CustomMessageReader_free(self); }
+ CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
+ LDKCustomMessageReader* operator &() { return &self; }
+ LDKCustomMessageReader* operator ->() { return &self; }
+ const LDKCustomMessageReader* operator &() const { return &self; }
+ const LDKCustomMessageReader* operator ->() const { return &self; }
+ /**
+ * Decodes a custom message to `CustomMessageType`. If the given message type is known to the
+ * implementation and the message could be decoded, must return `Ok(Some(message))`. If the
+ * message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
+ * occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
+ */
+ inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
+};
+class Type {
+private:
+ LDKType self;
+public:
+ Type(const Type&) = delete;
+ Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
+ Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
+ operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
+ ~Type() { Type_free(self); }
+ Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
+ LDKType* operator &() { return &self; }
+ LDKType* operator ->() { return &self; }
+ const LDKType* operator &() const { return &self; }
+ const LDKType* operator ->() const { return &self; }
+ /**
+ * Returns the type identifying the message payload.
+ */
+ inline uint16_t type_id();
+ /**
+ * Return a human-readable "debug" string describing this object
+ */
+ inline LDK::Str debug_str();
+};
class Invoice {
private:
LDKInvoice self;
const LDKChannelMonitorUpdate* operator &() const { return &self; }
const LDKChannelMonitorUpdate* operator ->() const { return &self; }
};
-class ChannelMonitorUpdateErr {
-private:
- LDKChannelMonitorUpdateErr self;
-public:
- ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
- ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
- ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
- operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
- ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
- LDKChannelMonitorUpdateErr* operator &() { return &self; }
- LDKChannelMonitorUpdateErr* operator ->() { return &self; }
- const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
- const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
-};
class MonitorUpdateError {
private:
LDKMonitorUpdateError self;
const LDKHTLCUpdate* operator &() const { return &self; }
const LDKHTLCUpdate* 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;
const LDKChannelMonitor* operator &() const { return &self; }
const LDKChannelMonitor* operator ->() const { return &self; }
};
-class Persist {
+class CustomMessageHandler {
private:
- LDKPersist self;
+ LDKCustomMessageHandler self;
public:
- Persist(const Persist&) = delete;
- Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
- Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
- operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
- ~Persist() { Persist_free(self); }
- Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
- LDKPersist* operator &() { return &self; }
- LDKPersist* operator ->() { return &self; }
- const LDKPersist* operator &() const { return &self; }
- const LDKPersist* operator ->() const { return &self; }
+ 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; }
/**
- * Persist a new channel's data. The data can be stored any way you want, but
- * the identifier provided by Rust-Lightning is the channel's outpoint (and
- * it is up to you to maintain a correct mapping between the outpoint and the
- * stored channel data). Note that you **must** persist every new monitor to
- * disk. See the `Persist` trait documentation for more details.
- *
- * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
- * and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
+ * Called with the message type that was received and the buffer to be read.
+ * Can return a `MessageHandlingError` if the message could not be handled.
*/
- inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data);
+ inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
/**
- * Update one channel's data. The provided `ChannelMonitor` has already
- * applied the given update.
- *
- * Note that on every update, you **must** persist either the
- * `ChannelMonitorUpdate` or the updated monitor itself to disk/backups. See
- * the `Persist` trait documentation for more details.
- *
- * If an implementer chooses to persist the updates only, they need to make
- * sure that all the updates are applied to the `ChannelMonitors` *before*
- * the set of channel monitors is given to the `ChannelManager`
- * deserialization routine. See [`ChannelMonitor::update_monitor`] for
- * applying a monitor update to a monitor. If full `ChannelMonitors` are
- * persisted, then there is no need to persist individual updates.
- *
- * Note that there could be a performance tradeoff between persisting complete
- * channel monitors on every update vs. persisting only updates and applying
- * them in batches. The size of each monitor grows `O(number of state updates)`
- * whereas updates are small and `O(1)`.
- *
- * See [`ChannelMonitor::write`] for writing out a `ChannelMonitor`,
- * [`ChannelMonitorUpdate::write`] for writing out an update, and
- * [`ChannelMonitorUpdateErr`] for requirements when returning errors.
+ * Gets the list of pending messages which were generated by the custom message
+ * handler, clearing the list in the process. The first tuple element must
+ * correspond to the intended recipients node ids. If no connection to one of the
+ * specified node does not exist, the message is simply not sent to it.
*/
- inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data);
+ inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
};
class IgnoringMessageHandler {
private:
const LDKPeerManager* operator &() const { return &self; }
const LDKPeerManager* 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;
const LDKNetworkGraph* operator &() const { return &self; }
const LDKNetworkGraph* operator ->() const { return &self; }
};
-class LockedNetworkGraph {
+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:
- LDKLockedNetworkGraph self;
+ LDKNetworkUpdate self;
public:
- LockedNetworkGraph(const LockedNetworkGraph&) = delete;
- LockedNetworkGraph(LockedNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(LockedNetworkGraph)); }
- LockedNetworkGraph(LDKLockedNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedNetworkGraph)); }
- operator LDKLockedNetworkGraph() && { LDKLockedNetworkGraph res = self; memset(&self, 0, sizeof(LDKLockedNetworkGraph)); return res; }
- ~LockedNetworkGraph() { LockedNetworkGraph_free(self); }
- LockedNetworkGraph& operator=(LockedNetworkGraph&& o) { LockedNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(LockedNetworkGraph)); return *this; }
- LDKLockedNetworkGraph* operator &() { return &self; }
- LDKLockedNetworkGraph* operator ->() { return &self; }
- const LDKLockedNetworkGraph* operator &() const { return &self; }
- const LDKLockedNetworkGraph* operator ->() const { return &self; }
+ 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 NetGraphMsgHandler {
private:
const LDKCommitmentUpdate* operator &() const { return &self; }
const LDKCommitmentUpdate* operator ->() const { return &self; }
};
-class HTLCFailChannelUpdate {
-private:
- LDKHTLCFailChannelUpdate self;
-public:
- HTLCFailChannelUpdate(const HTLCFailChannelUpdate&) = delete;
- HTLCFailChannelUpdate(HTLCFailChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCFailChannelUpdate)); }
- HTLCFailChannelUpdate(LDKHTLCFailChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCFailChannelUpdate)); }
- operator LDKHTLCFailChannelUpdate() && { LDKHTLCFailChannelUpdate res = self; memset(&self, 0, sizeof(LDKHTLCFailChannelUpdate)); return res; }
- ~HTLCFailChannelUpdate() { HTLCFailChannelUpdate_free(self); }
- HTLCFailChannelUpdate& operator=(HTLCFailChannelUpdate&& o) { HTLCFailChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCFailChannelUpdate)); return *this; }
- LDKHTLCFailChannelUpdate* operator &() { return &self; }
- LDKHTLCFailChannelUpdate* operator ->() { return &self; }
- const LDKHTLCFailChannelUpdate* operator &() const { return &self; }
- const LDKHTLCFailChannelUpdate* operator ->() const { return &self; }
-};
class ChannelMessageHandler {
private:
LDKChannelMessageHandler self;
* false or returning an Err otherwise.
*/
inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
- /**
- * Handle some updates to the route graph that we learned due to an outbound failed payment.
- */
- inline void handle_htlc_fail_channel_update(const struct LDKHTLCFailChannelUpdate *NONNULL_PTR update);
/**
* Gets a subset of the 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
*/
inline void log(const char *record);
};
+class Persist {
+private:
+ LDKPersist self;
+public:
+ Persist(const Persist&) = delete;
+ Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
+ Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
+ operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
+ ~Persist() { Persist_free(self); }
+ Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
+ LDKPersist* operator &() { return &self; }
+ LDKPersist* operator ->() { return &self; }
+ const LDKPersist* operator &() const { return &self; }
+ const LDKPersist* operator ->() const { return &self; }
+ /**
+ * Persist a new channel's data. The data can be stored any way you want, but
+ * the identifier provided by Rust-Lightning is the channel's outpoint (and
+ * it is up to you to maintain a correct mapping between the outpoint and the
+ * stored channel data). Note that you **must** persist every new monitor to
+ * disk. See the `Persist` trait documentation for more details.
+ *
+ * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
+ * and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
+ *
+ * [`Writeable::write`]: crate::util::ser::Writeable::write
+ */
+ inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data);
+ /**
+ * Update one channel's data. The provided `ChannelMonitor` has already
+ * applied the given update.
+ *
+ * Note that on every update, you **must** persist either the
+ * `ChannelMonitorUpdate` or the updated monitor itself to disk/backups. See
+ * the `Persist` trait documentation for more details.
+ *
+ * If an implementer chooses to persist the updates only, they need to make
+ * sure that all the updates are applied to the `ChannelMonitors` *before*
+ * the set of channel monitors is given to the `ChannelManager`
+ * deserialization routine. See [`ChannelMonitor::update_monitor`] for
+ * applying a monitor update to a monitor. If full `ChannelMonitors` are
+ * persisted, then there is no need to persist individual updates.
+ *
+ * Note that there could be a performance tradeoff between persisting complete
+ * channel monitors on every update vs. persisting only updates and applying
+ * them in batches. The size of each monitor grows `O(number of state updates)`
+ * whereas updates are small and `O(1)`.
+ *
+ * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
+ * [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
+ * [`ChannelMonitorUpdateErr`] for requirements when returning errors.
+ *
+ * [`Writeable::write`]: crate::util::ser::Writeable::write
+ */
+ inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data);
+};
+class LockedChannelMonitor {
+private:
+ LDKLockedChannelMonitor self;
+public:
+ LockedChannelMonitor(const LockedChannelMonitor&) = delete;
+ LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
+ LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
+ operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
+ ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
+ LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
+ LDKLockedChannelMonitor* operator &() { return &self; }
+ LDKLockedChannelMonitor* operator ->() { return &self; }
+ const LDKLockedChannelMonitor* operator &() const { return &self; }
+ const LDKLockedChannelMonitor* operator ->() const { return &self; }
+};
class ChainMonitor {
private:
LDKChainMonitor self;
const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
};
+class CResult_LockedChannelMonitorNoneZ {
+private:
+ LDKCResult_LockedChannelMonitorNoneZ self;
+public:
+ CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
+ CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
+ CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
+ operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
+ ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
+ CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
+ LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
+ LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
+ const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
+ const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
+};
class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
private:
LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
};
+class CVec_OutPointZ {
+private:
+ LDKCVec_OutPointZ self;
+public:
+ CVec_OutPointZ(const CVec_OutPointZ&) = delete;
+ CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
+ CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
+ operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
+ ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
+ CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
+ LDKCVec_OutPointZ* operator &() { return &self; }
+ LDKCVec_OutPointZ* operator ->() { return &self; }
+ const LDKCVec_OutPointZ* operator &() const { return &self; }
+ const LDKCVec_OutPointZ* operator ->() const { return &self; }
+};
class CResult_PositiveTimestampCreationErrorZ {
private:
LDKCResult_PositiveTimestampCreationErrorZ self;
const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_ChannelMonitorUpdateDecodeErrorZ {
+class COption_NetworkUpdateZ {
private:
- LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
+ LDKCOption_NetworkUpdateZ self;
public:
- CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
- CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
- CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
- operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
- ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
- CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
- LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
+ COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
+ COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
+ COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
+ operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
+ ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
+ COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
+ LDKCOption_NetworkUpdateZ* operator &() { return &self; }
+ LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
+ const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
+ const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
};
class COption_u64Z {
private:
const LDKCResult_TxOutAccessErrorZ* operator &() const { return &self; }
const LDKCResult_TxOutAccessErrorZ* operator ->() const { return &self; }
};
+class CResult_TrustedClosingTransactionNoneZ {
+private:
+ LDKCResult_TrustedClosingTransactionNoneZ self;
+public:
+ CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
+ CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
+ CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
+ operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
+ ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
+ CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
+ LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
+ LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
+ const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
+ const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
+};
+class CResult_ChannelMonitorUpdateDecodeErrorZ {
+private:
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
+public:
+ CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
+ CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
+ CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
+ operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
+ ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
+ CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_PublicKeyTypeZ {
+private:
+ LDKC2Tuple_PublicKeyTypeZ self;
+public:
+ C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
+ C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
+ C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
+ operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
+ ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
+ C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
+ LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
+ LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
+ const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
+ const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
+};
class CResult_NetAddressDecodeErrorZ {
private:
LDKCResult_NetAddressDecodeErrorZ self;
const LDKCResult_NetAddressDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_NetAddressDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_ChannelReestablishDecodeErrorZ {
+private:
+ LDKCResult_ChannelReestablishDecodeErrorZ self;
+public:
+ CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
+ CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
+ CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
+ operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
+ ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
+ CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
+};
class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
private:
LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_ChannelReestablishDecodeErrorZ {
+class CResult_CommitmentSignedDecodeErrorZ {
private:
- LDKCResult_ChannelReestablishDecodeErrorZ self;
-public:
- CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
- CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
- CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
- operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
- ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
- CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
- LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_GossipTimestampFilterDecodeErrorZ {
-private:
- LDKCResult_GossipTimestampFilterDecodeErrorZ self;
-public:
- CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
- CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
- CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
- operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
- ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
- CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
- LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
- LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_InvoiceSignOrCreationErrorZ {
-private:
- LDKCResult_InvoiceSignOrCreationErrorZ self;
-public:
- CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
- CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
- CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
- operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
- ~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
- CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
- LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
- LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
- const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
- const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
-};
-class CResult_CommitmentSignedDecodeErrorZ {
-private:
- LDKCResult_CommitmentSignedDecodeErrorZ self;
+ LDKCResult_CommitmentSignedDecodeErrorZ self;
public:
CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
};
+class CResult_GossipTimestampFilterDecodeErrorZ {
+private:
+ LDKCResult_GossipTimestampFilterDecodeErrorZ self;
+public:
+ CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
+ CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
+ CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
+ operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
+ ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
+ CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
+};
class COption_u32Z {
private:
LDKCOption_u32Z self;
const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
};
+class CResult_PaymentIdPaymentSendFailureZ {
+private:
+ LDKCResult_PaymentIdPaymentSendFailureZ self;
+public:
+ CResult_PaymentIdPaymentSendFailureZ(const CResult_PaymentIdPaymentSendFailureZ&) = delete;
+ CResult_PaymentIdPaymentSendFailureZ(CResult_PaymentIdPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); }
+ CResult_PaymentIdPaymentSendFailureZ(LDKCResult_PaymentIdPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); }
+ operator LDKCResult_PaymentIdPaymentSendFailureZ() && { LDKCResult_PaymentIdPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); return res; }
+ ~CResult_PaymentIdPaymentSendFailureZ() { CResult_PaymentIdPaymentSendFailureZ_free(self); }
+ CResult_PaymentIdPaymentSendFailureZ& operator=(CResult_PaymentIdPaymentSendFailureZ&& o) { CResult_PaymentIdPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); return *this; }
+ LDKCResult_PaymentIdPaymentSendFailureZ* operator &() { return &self; }
+ LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_PaymentIdPaymentSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceSignOrCreationErrorZ {
+private:
+ LDKCResult_InvoiceSignOrCreationErrorZ self;
+public:
+ CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
+ CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
+ CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
+ operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
+ ~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
+ CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
+ LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+};
class CResult_CommitmentTransactionDecodeErrorZ {
private:
LDKCResult_CommitmentTransactionDecodeErrorZ self;
const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
};
+class COption_FilterZ {
+private:
+ LDKCOption_FilterZ self;
+public:
+ COption_FilterZ(const COption_FilterZ&) = delete;
+ COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
+ COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
+ operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
+ ~COption_FilterZ() { COption_FilterZ_free(self); }
+ COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
+ LDKCOption_FilterZ* operator &() { return &self; }
+ LDKCOption_FilterZ* operator ->() { return &self; }
+ const LDKCOption_FilterZ* operator &() const { return &self; }
+ const LDKCOption_FilterZ* operator ->() const { return &self; }
+};
class CVec_TransactionOutputsZ {
private:
LDKCVec_TransactionOutputsZ self;
const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
};
-class C2Tuple_usizeTransactionZ {
-private:
- LDKC2Tuple_usizeTransactionZ self;
-public:
- C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
- C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
- C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
- operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
- ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
- C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
- LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
- LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
- const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
- const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
-};
class CResult_TxCreationKeysDecodeErrorZ {
private:
LDKCResult_TxCreationKeysDecodeErrorZ self;
const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
};
+class C2Tuple_usizeTransactionZ {
+private:
+ LDKC2Tuple_usizeTransactionZ self;
+public:
+ C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
+ C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
+ C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
+ operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
+ ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
+ C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
+ LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
+ LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
+ const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
+ const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
+};
class CResult_ChannelFeaturesDecodeErrorZ {
private:
LDKCResult_ChannelFeaturesDecodeErrorZ self;
const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
};
+class CVec_BalanceZ {
+private:
+ LDKCVec_BalanceZ self;
+public:
+ CVec_BalanceZ(const CVec_BalanceZ&) = delete;
+ CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
+ CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
+ operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
+ ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
+ CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
+ LDKCVec_BalanceZ* operator &() { return &self; }
+ LDKCVec_BalanceZ* operator ->() { return &self; }
+ const LDKCVec_BalanceZ* operator &() const { return &self; }
+ const LDKCVec_BalanceZ* operator ->() const { return &self; }
+};
class CResult_HTLCOutputInCommitmentDecodeErrorZ {
private:
LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
const LDKC2Tuple_BlockHashChannelMonitorZ* operator &() const { return &self; }
const LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() const { return &self; }
};
-class CResult_FundingSignedDecodeErrorZ {
+class CResult_NodeIdDecodeErrorZ {
private:
- LDKCResult_FundingSignedDecodeErrorZ self;
+ LDKCResult_NodeIdDecodeErrorZ self;
public:
- CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
- CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
- CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
- operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
- ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
- CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
- LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
- LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
+ CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
+ CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
+ CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
+ operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
+ ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
+ CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
+ LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_ShutdownScriptInvalidShutdownScriptZ {
private:
const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
};
+class CResult_FundingSignedDecodeErrorZ {
+private:
+ LDKCResult_FundingSignedDecodeErrorZ self;
+public:
+ CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
+ CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
+ CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
+ operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
+ ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
+ CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
+ LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
+};
class CResult_NetworkGraphDecodeErrorZ {
private:
LDKCResult_NetworkGraphDecodeErrorZ self;
const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
};
+class CResult_PaymentIdDecodeErrorZ {
+private:
+ LDKCResult_PaymentIdDecodeErrorZ self;
+public:
+ CResult_PaymentIdDecodeErrorZ(const CResult_PaymentIdDecodeErrorZ&) = delete;
+ CResult_PaymentIdDecodeErrorZ(CResult_PaymentIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdDecodeErrorZ)); }
+ CResult_PaymentIdDecodeErrorZ(LDKCResult_PaymentIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdDecodeErrorZ)); }
+ operator LDKCResult_PaymentIdDecodeErrorZ() && { LDKCResult_PaymentIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdDecodeErrorZ)); return res; }
+ ~CResult_PaymentIdDecodeErrorZ() { CResult_PaymentIdDecodeErrorZ_free(self); }
+ CResult_PaymentIdDecodeErrorZ& operator=(CResult_PaymentIdDecodeErrorZ&& o) { CResult_PaymentIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdDecodeErrorZ)); return *this; }
+ LDKCResult_PaymentIdDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PaymentIdDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PaymentIdDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PaymentIdDecodeErrorZ* operator ->() const { return &self; }
+};
class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
private:
LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
};
-class CResult_AcceptChannelDecodeErrorZ {
+class COption_AccessZ {
private:
- LDKCResult_AcceptChannelDecodeErrorZ self;
+ LDKCOption_AccessZ self;
public:
- CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
- CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
- CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
- operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
- ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
- CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
- LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
- LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
+ COption_AccessZ(const COption_AccessZ&) = delete;
+ COption_AccessZ(COption_AccessZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AccessZ)); }
+ COption_AccessZ(LDKCOption_AccessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AccessZ)); }
+ operator LDKCOption_AccessZ() && { LDKCOption_AccessZ res = self; memset(&self, 0, sizeof(LDKCOption_AccessZ)); return res; }
+ ~COption_AccessZ() { COption_AccessZ_free(self); }
+ COption_AccessZ& operator=(COption_AccessZ&& o) { COption_AccessZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AccessZ)); return *this; }
+ LDKCOption_AccessZ* operator &() { return &self; }
+ LDKCOption_AccessZ* operator ->() { return &self; }
+ const LDKCOption_AccessZ* operator &() const { return &self; }
+ const LDKCOption_AccessZ* operator ->() const { return &self; }
};
class C2Tuple_BlockHashChannelManagerZ {
private:
const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_PongDecodeErrorZ {
+class CResult_AcceptChannelDecodeErrorZ {
private:
- LDKCResult_PongDecodeErrorZ self;
+ LDKCResult_AcceptChannelDecodeErrorZ self;
public:
- CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
- CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
- CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
- operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
- ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
- CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
- LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
- LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+ CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
+ CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
+ CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
+ operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
+ ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
+ CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
+ LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_SignatureZ {
private:
const LDKCVec_u64Z* operator &() const { return &self; }
const LDKCVec_u64Z* operator ->() const { return &self; }
};
+class CResult_PongDecodeErrorZ {
+private:
+ LDKCResult_PongDecodeErrorZ self;
+public:
+ CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
+ CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
+ CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
+ operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
+ ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
+ CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
+ LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
+};
class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
private:
LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
};
+class C2Tuple_PaymentHashPaymentIdZ {
+private:
+ LDKC2Tuple_PaymentHashPaymentIdZ self;
+public:
+ C2Tuple_PaymentHashPaymentIdZ(const C2Tuple_PaymentHashPaymentIdZ&) = delete;
+ C2Tuple_PaymentHashPaymentIdZ(C2Tuple_PaymentHashPaymentIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); }
+ C2Tuple_PaymentHashPaymentIdZ(LDKC2Tuple_PaymentHashPaymentIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); }
+ operator LDKC2Tuple_PaymentHashPaymentIdZ() && { LDKC2Tuple_PaymentHashPaymentIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); return res; }
+ ~C2Tuple_PaymentHashPaymentIdZ() { C2Tuple_PaymentHashPaymentIdZ_free(self); }
+ C2Tuple_PaymentHashPaymentIdZ& operator=(C2Tuple_PaymentHashPaymentIdZ&& o) { C2Tuple_PaymentHashPaymentIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); return *this; }
+ LDKC2Tuple_PaymentHashPaymentIdZ* operator &() { return &self; }
+ LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() { return &self; }
+ const LDKC2Tuple_PaymentHashPaymentIdZ* operator &() const { return &self; }
+ const LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() const { return &self; }
+};
class CResult_StringErrorZ {
private:
LDKCResult_StringErrorZ self;
const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() const { return &self; }
const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() const { return &self; }
};
+class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
+private:
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ self;
+public:
+ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(const CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&) = delete;
+ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); }
+ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); }
+ operator LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ() && { LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); return res; }
+ ~CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ() { CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(self); }
+ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ& operator=(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& o) { CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); return *this; }
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() const { return &self; }
+};
class CVec_RouteHintZ {
private:
LDKCVec_RouteHintZ self;
const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
};
+class COption_CVec_NetAddressZZ {
+private:
+ LDKCOption_CVec_NetAddressZZ self;
+public:
+ COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
+ COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
+ COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
+ operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
+ ~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
+ COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
+ LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
+ LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
+ const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
+ const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
+};
class CResult_CVec_SignatureZNoneZ {
private:
LDKCResult_CVec_SignatureZNoneZ self;
const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
};
+class CResult__u832APIErrorZ {
+private:
+ LDKCResult__u832APIErrorZ self;
+public:
+ CResult__u832APIErrorZ(const CResult__u832APIErrorZ&) = delete;
+ CResult__u832APIErrorZ(CResult__u832APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832APIErrorZ)); }
+ CResult__u832APIErrorZ(LDKCResult__u832APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832APIErrorZ)); }
+ operator LDKCResult__u832APIErrorZ() && { LDKCResult__u832APIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult__u832APIErrorZ)); return res; }
+ ~CResult__u832APIErrorZ() { CResult__u832APIErrorZ_free(self); }
+ CResult__u832APIErrorZ& operator=(CResult__u832APIErrorZ&& o) { CResult__u832APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832APIErrorZ)); return *this; }
+ LDKCResult__u832APIErrorZ* operator &() { return &self; }
+ LDKCResult__u832APIErrorZ* operator ->() { return &self; }
+ const LDKCResult__u832APIErrorZ* operator &() const { return &self; }
+ const LDKCResult__u832APIErrorZ* operator ->() const { return &self; }
+};
class CResult_DescriptionCreationErrorZ {
private:
LDKCResult_DescriptionCreationErrorZ self;
const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
};
+class CVec_C2Tuple_PublicKeyTypeZZ {
+private:
+ LDKCVec_C2Tuple_PublicKeyTypeZZ self;
+public:
+ CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
+ CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
+ CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
+ operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
+ ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
+ CVec_C2Tuple_PublicKeyTypeZZ& operator=(CVec_C2Tuple_PublicKeyTypeZZ&& o) { CVec_C2Tuple_PublicKeyTypeZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); return *this; }
+ LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
+};
class CResult_RoutingFeesDecodeErrorZ {
private:
LDKCResult_RoutingFeesDecodeErrorZ self;
const LDKCVec_PublicKeyZ* operator &() const { return &self; }
const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
};
+class COption_TypeZ {
+private:
+ LDKCOption_TypeZ self;
+public:
+ COption_TypeZ(const COption_TypeZ&) = delete;
+ COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
+ COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
+ operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
+ ~COption_TypeZ() { COption_TypeZ_free(self); }
+ COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
+ LDKCOption_TypeZ* operator &() { return &self; }
+ LDKCOption_TypeZ* operator ->() { return &self; }
+ const LDKCOption_TypeZ* operator &() const { return &self; }
+ const LDKCOption_TypeZ* operator ->() const { return &self; }
+};
+class CResult_COption_TypeZDecodeErrorZ {
+private:
+ LDKCResult_COption_TypeZDecodeErrorZ self;
+public:
+ CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
+ CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
+ CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
+ operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
+ ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
+ CResult_COption_TypeZDecodeErrorZ& operator=(CResult_COption_TypeZDecodeErrorZ&& o) { CResult_COption_TypeZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
+};
class CResult_DirectionalChannelInfoDecodeErrorZ {
private:
LDKCResult_DirectionalChannelInfoDecodeErrorZ self;
const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
};
-class CResult_PaymentHashPaymentSendFailureZ {
-private:
- LDKCResult_PaymentHashPaymentSendFailureZ self;
-public:
- CResult_PaymentHashPaymentSendFailureZ(const CResult_PaymentHashPaymentSendFailureZ&) = delete;
- CResult_PaymentHashPaymentSendFailureZ(CResult_PaymentHashPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentHashPaymentSendFailureZ)); }
- CResult_PaymentHashPaymentSendFailureZ(LDKCResult_PaymentHashPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentHashPaymentSendFailureZ)); }
- operator LDKCResult_PaymentHashPaymentSendFailureZ() && { LDKCResult_PaymentHashPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentHashPaymentSendFailureZ)); return res; }
- ~CResult_PaymentHashPaymentSendFailureZ() { CResult_PaymentHashPaymentSendFailureZ_free(self); }
- CResult_PaymentHashPaymentSendFailureZ& operator=(CResult_PaymentHashPaymentSendFailureZ&& o) { CResult_PaymentHashPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentHashPaymentSendFailureZ)); return *this; }
- LDKCResult_PaymentHashPaymentSendFailureZ* operator &() { return &self; }
- LDKCResult_PaymentHashPaymentSendFailureZ* operator ->() { return &self; }
- const LDKCResult_PaymentHashPaymentSendFailureZ* operator &() const { return &self; }
- const LDKCResult_PaymentHashPaymentSendFailureZ* operator ->() const { return &self; }
-};
class CResult_SiPrefixNoneZ {
private:
LDKCResult_SiPrefixNoneZ self;
const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
};
+class CResult_NoneNoneZ {
+private:
+ LDKCResult_NoneNoneZ self;
+public:
+ CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
+ CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
+ CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
+ operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
+ ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
+ CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
+ LDKCResult_NoneNoneZ* operator &() { return &self; }
+ LDKCResult_NoneNoneZ* operator ->() { return &self; }
+ const LDKCResult_NoneNoneZ* operator &() const { return &self; }
+ const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
+};
class CResult_PrivateRouteCreationErrorZ {
private:
LDKCResult_PrivateRouteCreationErrorZ self;
const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
};
-class CResult_ChannelUpdateDecodeErrorZ {
-private:
- LDKCResult_ChannelUpdateDecodeErrorZ self;
-public:
- CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
- CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
- CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
- operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
- ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
- CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
- LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
-};
class CVec_APIErrorZ {
private:
LDKCVec_APIErrorZ self;
const LDKCVec_APIErrorZ* operator &() const { return &self; }
const LDKCVec_APIErrorZ* operator ->() const { return &self; }
};
+class CResult_ChannelUpdateDecodeErrorZ {
+private:
+ LDKCResult_ChannelUpdateDecodeErrorZ self;
+public:
+ CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
+ CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
+ CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
+ operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
+ ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
+ CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
+};
class CVec_UpdateFulfillHTLCZ {
private:
LDKCVec_UpdateFulfillHTLCZ self;
inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
(self.process_pending_events)(self.this_arg, handler);
}
-inline void EventHandler::handle_event(struct LDKEvent event) {
+inline void EventHandler::handle_event(const struct LDKEvent *NONNULL_PTR event) {
(self.handle_event)(self.this_arg, event);
}
+inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id) {
+ uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id);
+ return ret;
+}
inline LDKPublicKey BaseSign::get_per_commitment_point(uint64_t idx) {
LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
return ret;
LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
return ret;
}
+inline LDK::CResult_NoneNoneZ BaseSign::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx) {
+ LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx);
+ return ret;
+}
inline LDKThirtyTwoBytes BaseSign::channel_keys_id() {
LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
return ret;
LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx);
return ret;
}
+inline LDK::CResult_NoneNoneZ BaseSign::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
+ LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
+ return ret;
+}
inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, commitment_tx);
return ret;
LDK::CResult_SignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
return ret;
}
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(struct LDKTransaction closing_tx) {
+inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
LDK::CResult_SignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
return ret;
}
LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, invoice_preimage);
return ret;
}
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data) {
- LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, id, data);
+inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
+ LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
return ret;
}
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data) {
- LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, id, update, data);
+inline uint16_t Type::type_id() {
+ uint16_t ret = (self.type_id)(self.this_arg);
+ return ret;
+}
+inline LDK::Str Type::debug_str() {
+ LDK::Str ret = (self.debug_str)(self.this_arg);
+ return ret;
+}
+inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
+ LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
+ return ret;
+}
+inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
+ LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
return ret;
}
inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
return ret;
}
-inline void RoutingMessageHandler::handle_htlc_fail_channel_update(const struct LDKHTLCFailChannelUpdate *NONNULL_PTR update) {
- (self.handle_htlc_fail_channel_update)(self.this_arg, update);
-}
inline LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcements(uint64_t starting_point, uint8_t batch_amount) {
LDK::CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcements)(self.this_arg, starting_point, batch_amount);
return ret;
inline void Logger::log(const char *record) {
(self.log)(self.this_arg, record);
}
+inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data) {
+ LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, id, data);
+ return ret;
+}
+inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data) {
+ LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, id, update, data);
+ return ret;
+}
}