+ ErrorAction(const ErrorAction&) = delete;
+ ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
+ ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
+ operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
+ ~ErrorAction() { ErrorAction_free(self); }
+ ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
+ LDKErrorAction* operator &() { return &self; }
+ LDKErrorAction* operator ->() { return &self; }
+ const LDKErrorAction* operator &() const { return &self; }
+ const LDKErrorAction* operator ->() const { return &self; }
+};
+class LightningError {
+private:
+ LDKLightningError self;
+public:
+ LightningError(const LightningError&) = delete;
+ LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
+ LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
+ operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
+ ~LightningError() { LightningError_free(self); }
+ LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
+ LDKLightningError* operator &() { return &self; }
+ LDKLightningError* operator ->() { return &self; }
+ const LDKLightningError* operator &() const { return &self; }
+ const LDKLightningError* operator ->() const { return &self; }
+};
+class CommitmentUpdate {
+private:
+ LDKCommitmentUpdate self;
+public:
+ CommitmentUpdate(const CommitmentUpdate&) = delete;
+ CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
+ CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
+ operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
+ ~CommitmentUpdate() { CommitmentUpdate_free(self); }
+ CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
+ LDKCommitmentUpdate* operator &() { return &self; }
+ LDKCommitmentUpdate* operator ->() { return &self; }
+ const LDKCommitmentUpdate* operator &() const { return &self; }
+ const LDKCommitmentUpdate* operator ->() const { return &self; }
+};
+class ChannelMessageHandler {
+private:
+ LDKChannelMessageHandler self;
+public:
+ ChannelMessageHandler(const ChannelMessageHandler&) = delete;
+ ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
+ ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
+ operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
+ ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
+ ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
+ LDKChannelMessageHandler* operator &() { return &self; }
+ LDKChannelMessageHandler* operator ->() { return &self; }
+ const LDKChannelMessageHandler* operator &() const { return &self; }
+ const LDKChannelMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `open_channel` message from the given peer.
+ */
+ inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `open_channel2` message from the given peer.
+ */
+ inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `accept_channel` message from the given peer.
+ */
+ inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `accept_channel2` message from the given peer.
+ */
+ inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `funding_created` message from the given peer.
+ */
+ inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `funding_signed` message from the given peer.
+ */
+ inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_ready` message from the given peer.
+ */
+ inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `shutdown` message from the given peer.
+ */
+ inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `closing_signed` message from the given peer.
+ */
+ inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `stfu` message from the given peer.
+ */
+ inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_add_input message` from the given peer.
+ */
+ inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_add_output` message from the given peer.
+ */
+ inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_remove_input` message from the given peer.
+ */
+ inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_remove_output` message from the given peer.
+ */
+ inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_complete message` from the given peer.
+ */
+ inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_signatures` message from the given peer.
+ */
+ inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_init_rbf` message from the given peer.
+ */
+ inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_ack_rbf` message from the given peer.
+ */
+ inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_abort message` from the given peer.
+ */
+ inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_add_htlc` message from the given peer.
+ */
+ inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fulfill_htlc` message from the given peer.
+ */
+ inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fail_htlc` message from the given peer.
+ */
+ inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fail_malformed_htlc` message from the given peer.
+ */
+ inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `commitment_signed` message from the given peer.
+ */
+ inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `revoke_and_ack` message from the given peer.
+ */
+ inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fee` message from the given peer.
+ */
+ inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `announcement_signatures` message from the given peer.
+ */
+ inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
+ /**
+ * Indicates a connection to the peer failed/an existing connection was lost.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
+ /**
+ * Handle an incoming `channel_reestablish` message from the given peer.
+ */
+ inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_update` message from the given peer.
+ */
+ inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `error` message from the given peer.
+ */
+ inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+ /**
+ * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
+ *
+ * If it's `None`, then no particular network chain hash compatibility will be enforced when
+ * connecting to peers.
+ */
+ inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
+};
+class RoutingMessageHandler {
+private:
+ LDKRoutingMessageHandler self;
+public:
+ RoutingMessageHandler(const RoutingMessageHandler&) = delete;
+ RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
+ RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
+ operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
+ ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
+ RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
+ LDKRoutingMessageHandler* operator &() { return &self; }
+ LDKRoutingMessageHandler* operator ->() { return &self; }
+ const LDKRoutingMessageHandler* operator &() const { return &self; }
+ const LDKRoutingMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
+ * `false` or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+ /**
+ * Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
+ * or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_update` message, returning true if it should be forwarded on,
+ * `false` or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
+ /**
+ * Gets channel announcements and updates required to dump our routing table to a remote node,
+ * starting at the `short_channel_id` indicated by `starting_point` and including announcements
+ * for a single channel.
+ */
+ inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
+ /**
+ * Gets a node announcement required to dump our routing table to a remote node, starting at
+ * the node *after* the provided pubkey and including up to one announcement immediately
+ * higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
+ * If `None` is provided for `starting_point`, we start at the first node.
+ *
+ * Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
+ /**
+ * Called when a connection is established with a peer. This can be used to
+ * perform routing table synchronization using a strategy defined by the
+ * implementor.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
+ /**
+ * Handles the reply of a query we initiated to learn about channels
+ * for a given range of blocks. We can expect to receive one or more
+ * replies to a single query.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
+ /**
+ * Handles the reply of a query we initiated asking for routing gossip
+ * messages for a list of channels. We should receive this message when
+ * a node has completed its best effort to send us the pertaining routing
+ * gossip messages.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
+ /**
+ * Handles when a peer asks us to send a list of `short_channel_id`s
+ * for the requested range of blocks.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
+ /**
+ * Handles when a peer asks us to send routing gossip messages for a
+ * list of `short_channel_id`s.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
+ /**
+ * Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
+ * pending some async action. While there is no guarantee of the rate of future messages, the
+ * caller should seek to reduce the rate of new gossip messages handled, especially
+ * [`ChannelAnnouncement`]s.
+ */
+ inline bool processing_queue_high();
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class OnionMessageHandler {
+private:
+ LDKOnionMessageHandler self;
+public:
+ OnionMessageHandler(const OnionMessageHandler&) = delete;
+ OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
+ OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
+ operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
+ ~OnionMessageHandler() { OnionMessageHandler_free(self); }
+ OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
+ LDKOnionMessageHandler* operator &() { return &self; }
+ LDKOnionMessageHandler* operator ->() { return &self; }
+ const LDKOnionMessageHandler* operator &() const { return &self; }
+ const LDKOnionMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `onion_message` message from the given peer.
+ */
+ inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
+ /**
+ * Returns the next pending onion message for the peer with the given node id.
+ *
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
+ /**
+ * Called when a connection is established with a peer. Can be used to track which peers
+ * advertise onion message support and are online.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
+ /**
+ * Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
+ * drop and refuse to forward onion messages to this peer.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Performs actions that should happen roughly every ten seconds after startup. Allows handlers
+ * to drop any buffered onion messages intended for prospective peers.
+ */
+ inline void timer_tick_occurred();
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class FinalOnionHopData {
+private:
+ LDKFinalOnionHopData self;
+public:
+ FinalOnionHopData(const FinalOnionHopData&) = delete;
+ FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
+ FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
+ operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
+ ~FinalOnionHopData() { FinalOnionHopData_free(self); }
+ FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
+ LDKFinalOnionHopData* operator &() { return &self; }
+ LDKFinalOnionHopData* operator ->() { return &self; }
+ const LDKFinalOnionHopData* operator &() const { return &self; }
+ const LDKFinalOnionHopData* operator ->() const { return &self; }
+};
+class OnionPacket {
+private:
+ LDKOnionPacket self;
+public:
+ OnionPacket(const OnionPacket&) = delete;
+ OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
+ OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
+ operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
+ ~OnionPacket() { OnionPacket_free(self); }
+ OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
+ LDKOnionPacket* operator &() { return &self; }
+ LDKOnionPacket* operator ->() { return &self; }
+ const LDKOnionPacket* operator &() const { return &self; }
+ const LDKOnionPacket* operator ->() const { return &self; }
+};
+class TrampolineOnionPacket {
+private:
+ LDKTrampolineOnionPacket self;
+public:
+ TrampolineOnionPacket(const TrampolineOnionPacket&) = delete;
+ TrampolineOnionPacket(TrampolineOnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(TrampolineOnionPacket)); }
+ TrampolineOnionPacket(LDKTrampolineOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrampolineOnionPacket)); }
+ operator LDKTrampolineOnionPacket() && { LDKTrampolineOnionPacket res = self; memset(&self, 0, sizeof(LDKTrampolineOnionPacket)); return res; }
+ ~TrampolineOnionPacket() { TrampolineOnionPacket_free(self); }
+ TrampolineOnionPacket& operator=(TrampolineOnionPacket&& o) { TrampolineOnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(TrampolineOnionPacket)); return *this; }
+ LDKTrampolineOnionPacket* operator &() { return &self; }
+ LDKTrampolineOnionPacket* operator ->() { return &self; }
+ const LDKTrampolineOnionPacket* operator &() const { return &self; }
+ const LDKTrampolineOnionPacket* operator ->() const { return &self; }
+};
+class Level {
+private:
+ LDKLevel self;
+public:
+ Level(const Level&) = delete;
+ Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
+ Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
+ operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
+ Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
+ LDKLevel* operator &() { return &self; }
+ LDKLevel* operator ->() { return &self; }
+ const LDKLevel* operator &() const { return &self; }
+ const LDKLevel* operator ->() const { return &self; }
+};
+class Record {
+private:
+ LDKRecord self;
+public:
+ Record(const Record&) = delete;
+ Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
+ Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
+ operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
+ ~Record() { Record_free(self); }
+ Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
+ LDKRecord* operator &() { return &self; }
+ LDKRecord* operator ->() { return &self; }
+ const LDKRecord* operator &() const { return &self; }
+ const LDKRecord* operator ->() const { return &self; }
+};
+class Logger {
+private:
+ LDKLogger self;
+public:
+ Logger(const Logger&) = delete;
+ Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
+ Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
+ operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
+ ~Logger() { Logger_free(self); }
+ Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
+ LDKLogger* operator &() { return &self; }
+ LDKLogger* operator ->() { return &self; }
+ const LDKLogger* operator &() const { return &self; }
+ const LDKLogger* operator ->() const { return &self; }
+ /**
+ * Logs the [`Record`].
+ */
+ inline void log(struct LDKRecord record);
+};
+class InboundHTLCStateDetails {
+private:
+ LDKInboundHTLCStateDetails self;
+public:
+ InboundHTLCStateDetails(const InboundHTLCStateDetails&) = delete;
+ InboundHTLCStateDetails(InboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCStateDetails)); }
+ InboundHTLCStateDetails(LDKInboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCStateDetails)); }
+ operator LDKInboundHTLCStateDetails() && { LDKInboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCStateDetails)); return res; }
+ InboundHTLCStateDetails& operator=(InboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(InboundHTLCStateDetails)); return *this; }
+ LDKInboundHTLCStateDetails* operator &() { return &self; }
+ LDKInboundHTLCStateDetails* operator ->() { return &self; }
+ const LDKInboundHTLCStateDetails* operator &() const { return &self; }
+ const LDKInboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class InboundHTLCDetails {
+private:
+ LDKInboundHTLCDetails self;
+public:
+ InboundHTLCDetails(const InboundHTLCDetails&) = delete;
+ InboundHTLCDetails(InboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCDetails)); }
+ InboundHTLCDetails(LDKInboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCDetails)); }
+ operator LDKInboundHTLCDetails() && { LDKInboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCDetails)); return res; }
+ ~InboundHTLCDetails() { InboundHTLCDetails_free(self); }
+ InboundHTLCDetails& operator=(InboundHTLCDetails&& o) { InboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCDetails)); return *this; }
+ LDKInboundHTLCDetails* operator &() { return &self; }
+ LDKInboundHTLCDetails* operator ->() { return &self; }
+ const LDKInboundHTLCDetails* operator &() const { return &self; }
+ const LDKInboundHTLCDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCStateDetails {
+private:
+ LDKOutboundHTLCStateDetails self;
+public:
+ OutboundHTLCStateDetails(const OutboundHTLCStateDetails&) = delete;
+ OutboundHTLCStateDetails(OutboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCStateDetails)); }
+ OutboundHTLCStateDetails(LDKOutboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCStateDetails)); }
+ operator LDKOutboundHTLCStateDetails() && { LDKOutboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCStateDetails)); return res; }
+ OutboundHTLCStateDetails& operator=(OutboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(OutboundHTLCStateDetails)); return *this; }
+ LDKOutboundHTLCStateDetails* operator &() { return &self; }
+ LDKOutboundHTLCStateDetails* operator ->() { return &self; }
+ const LDKOutboundHTLCStateDetails* operator &() const { return &self; }
+ const LDKOutboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCDetails {
+private:
+ LDKOutboundHTLCDetails self;
+public:
+ OutboundHTLCDetails(const OutboundHTLCDetails&) = delete;
+ OutboundHTLCDetails(OutboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCDetails)); }
+ OutboundHTLCDetails(LDKOutboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCDetails)); }
+ operator LDKOutboundHTLCDetails() && { LDKOutboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCDetails)); return res; }
+ ~OutboundHTLCDetails() { OutboundHTLCDetails_free(self); }
+ OutboundHTLCDetails& operator=(OutboundHTLCDetails&& o) { OutboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(OutboundHTLCDetails)); return *this; }
+ LDKOutboundHTLCDetails* operator &() { return &self; }
+ LDKOutboundHTLCDetails* operator ->() { return &self; }
+ const LDKOutboundHTLCDetails* operator &() const { return &self; }
+ const LDKOutboundHTLCDetails* operator ->() const { return &self; }
+};
+class CounterpartyForwardingInfo {
+private:
+ LDKCounterpartyForwardingInfo self;
+public:
+ CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
+ CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
+ CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
+ operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
+ ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
+ CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
+ LDKCounterpartyForwardingInfo* operator &() { return &self; }
+ LDKCounterpartyForwardingInfo* operator ->() { return &self; }
+ const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
+ const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
+};
+class ChannelCounterparty {
+private:
+ LDKChannelCounterparty self;
+public:
+ ChannelCounterparty(const ChannelCounterparty&) = delete;
+ ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
+ ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
+ operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
+ ~ChannelCounterparty() { ChannelCounterparty_free(self); }
+ ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
+ LDKChannelCounterparty* operator &() { return &self; }
+ LDKChannelCounterparty* operator ->() { return &self; }
+ const LDKChannelCounterparty* operator &() const { return &self; }
+ const LDKChannelCounterparty* operator ->() const { return &self; }
+};
+class ChannelDetails {
+private:
+ LDKChannelDetails self;
+public:
+ ChannelDetails(const ChannelDetails&) = delete;
+ ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
+ ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
+ operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
+ ~ChannelDetails() { ChannelDetails_free(self); }
+ ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
+ LDKChannelDetails* operator &() { return &self; }
+ LDKChannelDetails* operator ->() { return &self; }
+ const LDKChannelDetails* operator &() const { return &self; }
+ const LDKChannelDetails* operator ->() const { return &self; }
+};
+class ChannelShutdownState {
+private:
+ LDKChannelShutdownState self;
+public:
+ ChannelShutdownState(const ChannelShutdownState&) = delete;
+ ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
+ ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
+ operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
+ ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
+ LDKChannelShutdownState* operator &() { return &self; }
+ LDKChannelShutdownState* operator ->() { return &self; }
+ const LDKChannelShutdownState* operator &() const { return &self; }
+ const LDKChannelShutdownState* operator ->() const { return &self; }
+};
+class FutureCallback {
+private:
+ LDKFutureCallback self;
+public:
+ FutureCallback(const FutureCallback&) = delete;
+ FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
+ FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
+ operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
+ ~FutureCallback() { FutureCallback_free(self); }
+ FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
+ LDKFutureCallback* operator &() { return &self; }
+ LDKFutureCallback* operator ->() { return &self; }
+ const LDKFutureCallback* operator &() const { return &self; }
+ const LDKFutureCallback* operator ->() const { return &self; }
+ /**
+ * The method which is called.
+ */
+ inline void call();
+};
+class Future {
+private:
+ LDKFuture self;
+public:
+ Future(const Future&) = delete;
+ Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
+ Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
+ operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
+ ~Future() { Future_free(self); }
+ Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
+ LDKFuture* operator &() { return &self; }
+ LDKFuture* operator ->() { return &self; }
+ const LDKFuture* operator &() const { return &self; }
+ const LDKFuture* operator ->() const { return &self; }
+};
+class Sleeper {
+private:
+ LDKSleeper self;
+public:
+ Sleeper(const Sleeper&) = delete;
+ Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
+ Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
+ operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
+ ~Sleeper() { Sleeper_free(self); }
+ Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
+ LDKSleeper* operator &() { return &self; }
+ LDKSleeper* operator ->() { return &self; }
+ const LDKSleeper* operator &() const { return &self; }
+ const LDKSleeper* operator ->() const { return &self; }
+};
+class AsyncPaymentsMessageHandler {
+private:
+ LDKAsyncPaymentsMessageHandler self;
+public:
+ AsyncPaymentsMessageHandler(const AsyncPaymentsMessageHandler&) = delete;
+ AsyncPaymentsMessageHandler(AsyncPaymentsMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); }
+ AsyncPaymentsMessageHandler(LDKAsyncPaymentsMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); }
+ operator LDKAsyncPaymentsMessageHandler() && { LDKAsyncPaymentsMessageHandler res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); return res; }
+ ~AsyncPaymentsMessageHandler() { AsyncPaymentsMessageHandler_free(self); }
+ AsyncPaymentsMessageHandler& operator=(AsyncPaymentsMessageHandler&& o) { AsyncPaymentsMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); return *this; }
+ LDKAsyncPaymentsMessageHandler* operator &() { return &self; }
+ LDKAsyncPaymentsMessageHandler* operator ->() { return &self; }
+ const LDKAsyncPaymentsMessageHandler* operator &() const { return &self; }
+ const LDKAsyncPaymentsMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle a [`HeldHtlcAvailable`] message. A [`ReleaseHeldHtlc`] should be returned to release
+ * the held funds.
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ held_htlc_available(struct LDKHeldHtlcAvailable message, struct LDKResponder responder);
+ /**
+ * Handle a [`ReleaseHeldHtlc`] message. If authentication of the message succeeds, an HTLC
+ * should be released to the corresponding payee.
+ */
+ inline void release_held_htlc(struct LDKReleaseHeldHtlc message);
+ /**
+ * Release any [`AsyncPaymentsMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating an async payment flow rather than in response
+ * to another message.
+ */
+ inline LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class AsyncPaymentsMessage {
+private:
+ LDKAsyncPaymentsMessage self;
+public:
+ AsyncPaymentsMessage(const AsyncPaymentsMessage&) = delete;
+ AsyncPaymentsMessage(AsyncPaymentsMessage&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessage)); }
+ AsyncPaymentsMessage(LDKAsyncPaymentsMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessage)); }
+ operator LDKAsyncPaymentsMessage() && { LDKAsyncPaymentsMessage res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessage)); return res; }
+ ~AsyncPaymentsMessage() { AsyncPaymentsMessage_free(self); }
+ AsyncPaymentsMessage& operator=(AsyncPaymentsMessage&& o) { AsyncPaymentsMessage_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessage)); return *this; }
+ LDKAsyncPaymentsMessage* operator &() { return &self; }
+ LDKAsyncPaymentsMessage* operator ->() { return &self; }
+ const LDKAsyncPaymentsMessage* operator &() const { return &self; }
+ const LDKAsyncPaymentsMessage* operator ->() const { return &self; }
+};
+class HeldHtlcAvailable {
+private:
+ LDKHeldHtlcAvailable self;
+public:
+ HeldHtlcAvailable(const HeldHtlcAvailable&) = delete;
+ HeldHtlcAvailable(HeldHtlcAvailable&& o) : self(o.self) { memset(&o, 0, sizeof(HeldHtlcAvailable)); }
+ HeldHtlcAvailable(LDKHeldHtlcAvailable&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHeldHtlcAvailable)); }
+ operator LDKHeldHtlcAvailable() && { LDKHeldHtlcAvailable res = self; memset(&self, 0, sizeof(LDKHeldHtlcAvailable)); return res; }
+ ~HeldHtlcAvailable() { HeldHtlcAvailable_free(self); }
+ HeldHtlcAvailable& operator=(HeldHtlcAvailable&& o) { HeldHtlcAvailable_free(self); self = o.self; memset(&o, 0, sizeof(HeldHtlcAvailable)); return *this; }
+ LDKHeldHtlcAvailable* operator &() { return &self; }
+ LDKHeldHtlcAvailable* operator ->() { return &self; }
+ const LDKHeldHtlcAvailable* operator &() const { return &self; }
+ const LDKHeldHtlcAvailable* operator ->() const { return &self; }
+};
+class ReleaseHeldHtlc {
+private:
+ LDKReleaseHeldHtlc self;
+public:
+ ReleaseHeldHtlc(const ReleaseHeldHtlc&) = delete;
+ ReleaseHeldHtlc(ReleaseHeldHtlc&& o) : self(o.self) { memset(&o, 0, sizeof(ReleaseHeldHtlc)); }
+ ReleaseHeldHtlc(LDKReleaseHeldHtlc&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReleaseHeldHtlc)); }
+ operator LDKReleaseHeldHtlc() && { LDKReleaseHeldHtlc res = self; memset(&self, 0, sizeof(LDKReleaseHeldHtlc)); return res; }
+ ~ReleaseHeldHtlc() { ReleaseHeldHtlc_free(self); }
+ ReleaseHeldHtlc& operator=(ReleaseHeldHtlc&& o) { ReleaseHeldHtlc_free(self); self = o.self; memset(&o, 0, sizeof(ReleaseHeldHtlc)); return *this; }
+ LDKReleaseHeldHtlc* operator &() { return &self; }
+ LDKReleaseHeldHtlc* operator ->() { return &self; }
+ const LDKReleaseHeldHtlc* operator &() const { return &self; }
+ const LDKReleaseHeldHtlc* operator ->() const { return &self; }
+};
+class OffersMessageHandler {
+private:
+ LDKOffersMessageHandler self;
+public:
+ OffersMessageHandler(const OffersMessageHandler&) = delete;
+ OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
+ OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
+ operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
+ ~OffersMessageHandler() { OffersMessageHandler_free(self); }
+ OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
+ LDKOffersMessageHandler* operator &() { return &self; }
+ LDKOffersMessageHandler* operator ->() { return &self; }
+ const LDKOffersMessageHandler* operator &() const { return &self; }
+ const LDKOffersMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
+ * or replying with an error.
+ *
+ * The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
+ *
+ * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ handle_message(struct LDKOffersMessage message, struct LDKCOption_OffersContextZ context, struct LDKResponder responder);
+ /**
+ * Releases any [`OffersMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating a payment flow rather than in response to
+ * another message. The latter should use the return value of [`Self::handle_message`].
+ */
+ inline LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class OffersMessage {
+private:
+ LDKOffersMessage self;
+public:
+ OffersMessage(const OffersMessage&) = delete;
+ OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
+ OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
+ operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
+ ~OffersMessage() { OffersMessage_free(self); }
+ OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
+ LDKOffersMessage* operator &() { return &self; }
+ LDKOffersMessage* operator ->() { return &self; }
+ const LDKOffersMessage* operator &() const { return &self; }
+ const LDKOffersMessage* operator ->() const { return &self; }
+};
+class HTLCClaim {
+private:
+ LDKHTLCClaim self;
+public:
+ HTLCClaim(const HTLCClaim&) = delete;
+ HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
+ HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
+ operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
+ HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
+ LDKHTLCClaim* operator &() { return &self; }
+ LDKHTLCClaim* operator ->() { return &self; }
+ const LDKHTLCClaim* operator &() const { return &self; }
+ const LDKHTLCClaim* operator ->() const { return &self; }
+};
+class CounterpartyCommitmentSecrets {
+private:
+ LDKCounterpartyCommitmentSecrets self;
+public:
+ CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
+ CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
+ CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
+ operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
+ ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
+ CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
+ LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
+ LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
+ const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
+ const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
+};
+class TxCreationKeys {
+private:
+ LDKTxCreationKeys self;
+public:
+ TxCreationKeys(const TxCreationKeys&) = delete;
+ TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
+ TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
+ operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
+ ~TxCreationKeys() { TxCreationKeys_free(self); }
+ TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
+ LDKTxCreationKeys* operator &() { return &self; }
+ LDKTxCreationKeys* operator ->() { return &self; }
+ const LDKTxCreationKeys* operator &() const { return &self; }
+ const LDKTxCreationKeys* operator ->() const { return &self; }
+};
+class ChannelPublicKeys {
+private:
+ LDKChannelPublicKeys self;
+public:
+ ChannelPublicKeys(const ChannelPublicKeys&) = delete;
+ ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
+ ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
+ operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
+ ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
+ ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
+ LDKChannelPublicKeys* operator &() { return &self; }
+ LDKChannelPublicKeys* operator ->() { return &self; }
+ const LDKChannelPublicKeys* operator &() const { return &self; }
+ const LDKChannelPublicKeys* operator ->() const { return &self; }
+};
+class HTLCOutputInCommitment {
+private:
+ LDKHTLCOutputInCommitment self;
+public:
+ HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
+ HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
+ HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
+ operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
+ ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
+ HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
+ LDKHTLCOutputInCommitment* operator &() { return &self; }
+ LDKHTLCOutputInCommitment* operator ->() { return &self; }
+ const LDKHTLCOutputInCommitment* operator &() const { return &self; }
+ const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
+};
+class ChannelTransactionParameters {
+private:
+ LDKChannelTransactionParameters self;
+public:
+ ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
+ ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
+ ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
+ operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
+ ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
+ ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
+ LDKChannelTransactionParameters* operator &() { return &self; }
+ LDKChannelTransactionParameters* operator ->() { return &self; }
+ const LDKChannelTransactionParameters* operator &() const { return &self; }
+ const LDKChannelTransactionParameters* operator ->() const { return &self; }
+};
+class CounterpartyChannelTransactionParameters {
+private:
+ LDKCounterpartyChannelTransactionParameters self;
+public:
+ CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
+ CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
+ CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
+ operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
+ ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
+ CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
+ LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
+ LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
+ const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
+ const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
+};
+class DirectedChannelTransactionParameters {
+private:
+ LDKDirectedChannelTransactionParameters self;
+public:
+ DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
+ DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
+ DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
+ operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
+ ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
+ DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
+ LDKDirectedChannelTransactionParameters* operator &() { return &self; }
+ LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
+ const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
+ const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
+};
+class HolderCommitmentTransaction {
+private:
+ LDKHolderCommitmentTransaction self;
+public:
+ HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
+ HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
+ HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
+ operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
+ ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
+ HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
+ LDKHolderCommitmentTransaction* operator &() { return &self; }
+ LDKHolderCommitmentTransaction* operator ->() { return &self; }
+ const LDKHolderCommitmentTransaction* operator &() const { return &self; }
+ const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
+};
+class BuiltCommitmentTransaction {
+private:
+ LDKBuiltCommitmentTransaction self;
+public:
+ BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
+ BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
+ BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
+ operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
+ ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
+ BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
+ LDKBuiltCommitmentTransaction* operator &() { return &self; }
+ LDKBuiltCommitmentTransaction* operator ->() { return &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;
+public:
+ CommitmentTransaction(const CommitmentTransaction&) = delete;
+ CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
+ CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
+ operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
+ ~CommitmentTransaction() { CommitmentTransaction_free(self); }
+ CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
+ LDKCommitmentTransaction* operator &() { return &self; }
+ LDKCommitmentTransaction* operator ->() { return &self; }
+ const LDKCommitmentTransaction* operator &() const { return &self; }
+ const LDKCommitmentTransaction* operator ->() const { return &self; }
+};
+class TrustedCommitmentTransaction {
+private:
+ LDKTrustedCommitmentTransaction self;
+public:
+ TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
+ TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
+ TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
+ operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
+ ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
+ TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
+ LDKTrustedCommitmentTransaction* operator &() { return &self; }
+ LDKTrustedCommitmentTransaction* operator ->() { return &self; }
+ const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
+ const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
+};
+class ShutdownScript {
+private:
+ LDKShutdownScript self;
+public:
+ ShutdownScript(const ShutdownScript&) = delete;
+ ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
+ ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
+ operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
+ ~ShutdownScript() { ShutdownScript_free(self); }
+ ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
+ LDKShutdownScript* operator &() { return &self; }
+ LDKShutdownScript* operator ->() { return &self; }
+ const LDKShutdownScript* operator &() const { return &self; }
+ const LDKShutdownScript* operator ->() const { return &self; }
+};
+class InvalidShutdownScript {
+private:
+ LDKInvalidShutdownScript self;
+public:
+ InvalidShutdownScript(const InvalidShutdownScript&) = delete;
+ InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
+ InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
+ operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
+ ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
+ InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
+ LDKInvalidShutdownScript* operator &() { return &self; }
+ LDKInvalidShutdownScript* operator ->() { return &self; }
+ const LDKInvalidShutdownScript* operator &() const { return &self; }
+ const LDKInvalidShutdownScript* operator ->() const { return &self; }
+};
+class Bolt12ParseError {
+private:
+ LDKBolt12ParseError self;
+public:
+ Bolt12ParseError(const Bolt12ParseError&) = delete;
+ Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
+ Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
+ operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
+ ~Bolt12ParseError() { Bolt12ParseError_free(self); }
+ Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
+ LDKBolt12ParseError* operator &() { return &self; }
+ LDKBolt12ParseError* operator ->() { return &self; }
+ const LDKBolt12ParseError* operator &() const { return &self; }
+ const LDKBolt12ParseError* operator ->() const { return &self; }
+};
+class Bolt12SemanticError {
+private:
+ LDKBolt12SemanticError self;
+public:
+ Bolt12SemanticError(const Bolt12SemanticError&) = delete;
+ Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
+ Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
+ operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
+ Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
+ LDKBolt12SemanticError* operator &() { return &self; }
+ LDKBolt12SemanticError* operator ->() { return &self; }
+ const LDKBolt12SemanticError* operator &() const { return &self; }
+ const LDKBolt12SemanticError* operator ->() const { return &self; }
+};
+class BroadcasterInterface {
+private:
+ LDKBroadcasterInterface self;
+public:
+ BroadcasterInterface(const BroadcasterInterface&) = delete;
+ BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
+ BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
+ operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
+ ~BroadcasterInterface() { BroadcasterInterface_free(self); }
+ BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
+ LDKBroadcasterInterface* operator &() { return &self; }
+ LDKBroadcasterInterface* operator ->() { return &self; }
+ const LDKBroadcasterInterface* operator &() const { return &self; }
+ const LDKBroadcasterInterface* operator ->() const { return &self; }
+ /**
+ * Sends a list of transactions out to (hopefully) be mined.
+ * This only needs to handle the actual broadcasting of transactions, LDK will automatically
+ * rebroadcast transactions that haven't made it into a block.
+ *
+ * In some cases LDK may attempt to broadcast a transaction which double-spends another
+ * and this isn't a bug and can be safely ignored.
+ *
+ * If more than one transaction is given, these transactions should be considered to be a
+ * package and broadcast together. Some of the transactions may or may not depend on each other,
+ * be sure to manage both cases correctly.
+ *
+ * Bitcoin transaction packages are defined in BIP 331 and here:
+ * <https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md>
+ */
+ inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
+};
+class ConfirmationTarget {
+private:
+ LDKConfirmationTarget self;
+public:
+ ConfirmationTarget(const ConfirmationTarget&) = delete;
+ ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
+ ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
+ operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
+ ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
+ LDKConfirmationTarget* operator &() { return &self; }
+ LDKConfirmationTarget* operator ->() { return &self; }
+ const LDKConfirmationTarget* operator &() const { return &self; }
+ const LDKConfirmationTarget* operator ->() const { return &self; }
+};
+class FeeEstimator {
+private:
+ LDKFeeEstimator self;
+public:
+ FeeEstimator(const FeeEstimator&) = delete;
+ FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
+ FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
+ operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
+ ~FeeEstimator() { FeeEstimator_free(self); }
+ FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
+ LDKFeeEstimator* operator &() { return &self; }
+ LDKFeeEstimator* operator ->() { return &self; }
+ const LDKFeeEstimator* operator &() const { return &self; }
+ const LDKFeeEstimator* operator ->() const { return &self; }
+ /**
+ * Gets estimated satoshis of fee required per 1000 Weight-Units.
+ *
+ * LDK will wrap this method and ensure that the value returned is no smaller than 253
+ * (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
+ *
+ * The following unit conversions can be used to convert to sats/KW:
+ * * satoshis-per-byte * 250
+ * * satoshis-per-kbyte / 4
+ */
+ inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
+};
+class Packet {
+private:
+ LDKPacket self;
+public:
+ Packet(const Packet&) = delete;
+ Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
+ Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
+ operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
+ ~Packet() { Packet_free(self); }
+ Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
+ LDKPacket* operator &() { return &self; }
+ LDKPacket* operator ->() { return &self; }
+ const LDKPacket* operator &() const { return &self; }
+ const LDKPacket* operator ->() const { return &self; }
+};
+class ParsedOnionMessageContents {
+private:
+ LDKParsedOnionMessageContents self;
+public:
+ ParsedOnionMessageContents(const ParsedOnionMessageContents&) = delete;
+ ParsedOnionMessageContents(ParsedOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(ParsedOnionMessageContents)); }
+ ParsedOnionMessageContents(LDKParsedOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParsedOnionMessageContents)); }
+ operator LDKParsedOnionMessageContents() && { LDKParsedOnionMessageContents res = self; memset(&self, 0, sizeof(LDKParsedOnionMessageContents)); return res; }
+ ~ParsedOnionMessageContents() { ParsedOnionMessageContents_free(self); }
+ ParsedOnionMessageContents& operator=(ParsedOnionMessageContents&& o) { ParsedOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(ParsedOnionMessageContents)); return *this; }
+ LDKParsedOnionMessageContents* operator &() { return &self; }
+ LDKParsedOnionMessageContents* operator ->() { return &self; }
+ const LDKParsedOnionMessageContents* operator &() const { return &self; }
+ const LDKParsedOnionMessageContents* operator ->() const { return &self; }
+};
+class OnionMessageContents {
+private:
+ LDKOnionMessageContents self;
+public:
+ OnionMessageContents(const OnionMessageContents&) = delete;
+ OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
+ OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
+ operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
+ ~OnionMessageContents() { OnionMessageContents_free(self); }
+ OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
+ LDKOnionMessageContents* operator &() { return &self; }
+ LDKOnionMessageContents* operator ->() { return &self; }
+ const LDKOnionMessageContents* operator &() const { return &self; }
+ const LDKOnionMessageContents* operator ->() const { return &self; }
+ /**
+ * Returns the TLV type identifying the message contents. MUST be >= 64.
+ */
+ inline uint64_t tlv_type();
+ /**
+ * Returns the message type
+ */
+ inline LDK::Str msg_type();
+ /**
+ * Return a human-readable "debug" string describing this object
+ */
+ inline LDK::Str debug_str();
+};
+class FundingInfo {
+private:
+ LDKFundingInfo self;
+public:
+ FundingInfo(const FundingInfo&) = delete;
+ FundingInfo(FundingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(FundingInfo)); }
+ FundingInfo(LDKFundingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingInfo)); }
+ operator LDKFundingInfo() && { LDKFundingInfo res = self; memset(&self, 0, sizeof(LDKFundingInfo)); return res; }
+ ~FundingInfo() { FundingInfo_free(self); }
+ FundingInfo& operator=(FundingInfo&& o) { FundingInfo_free(self); self = o.self; memset(&o, 0, sizeof(FundingInfo)); return *this; }
+ LDKFundingInfo* operator &() { return &self; }
+ LDKFundingInfo* operator ->() { return &self; }
+ const LDKFundingInfo* operator &() const { return &self; }
+ const LDKFundingInfo* operator ->() const { return &self; }
+};
+class PaymentPurpose {
+private:
+ LDKPaymentPurpose self;
+public:
+ PaymentPurpose(const PaymentPurpose&) = delete;
+ PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
+ PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
+ operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
+ ~PaymentPurpose() { PaymentPurpose_free(self); }
+ PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
+ LDKPaymentPurpose* operator &() { return &self; }
+ LDKPaymentPurpose* operator ->() { return &self; }
+ const LDKPaymentPurpose* operator &() const { return &self; }
+ const LDKPaymentPurpose* operator ->() const { return &self; }
+};
+class ClaimedHTLC {
+private:
+ LDKClaimedHTLC self;
+public:
+ ClaimedHTLC(const ClaimedHTLC&) = delete;
+ ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
+ ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
+ operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
+ ~ClaimedHTLC() { ClaimedHTLC_free(self); }
+ ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
+ LDKClaimedHTLC* operator &() { return &self; }
+ LDKClaimedHTLC* operator ->() { return &self; }
+ const LDKClaimedHTLC* operator &() const { return &self; }
+ const LDKClaimedHTLC* operator ->() const { return &self; }
+};
+class PathFailure {
+private:
+ LDKPathFailure self;
+public:
+ PathFailure(const PathFailure&) = delete;
+ PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
+ PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
+ operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
+ ~PathFailure() { PathFailure_free(self); }
+ PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
+ LDKPathFailure* operator &() { return &self; }
+ LDKPathFailure* operator ->() { return &self; }
+ const LDKPathFailure* operator &() const { return &self; }
+ const LDKPathFailure* 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 HTLCDestination {
+private:
+ LDKHTLCDestination self;
+public:
+ HTLCDestination(const HTLCDestination&) = delete;
+ HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
+ HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
+ operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
+ ~HTLCDestination() { HTLCDestination_free(self); }
+ HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
+ LDKHTLCDestination* operator &() { return &self; }
+ LDKHTLCDestination* operator ->() { return &self; }
+ const LDKHTLCDestination* operator &() const { return &self; }
+ const LDKHTLCDestination* operator ->() const { return &self; }
+};
+class PaymentFailureReason {
+private:
+ LDKPaymentFailureReason self;
+public:
+ PaymentFailureReason(const PaymentFailureReason&) = delete;
+ PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
+ PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
+ operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
+ PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
+ LDKPaymentFailureReason* operator &() { return &self; }
+ LDKPaymentFailureReason* operator ->() { return &self; }
+ const LDKPaymentFailureReason* operator &() const { return &self; }
+ const LDKPaymentFailureReason* operator ->() const { return &self; }
+};
+class Event {
+private:
+ LDKEvent self;
+public:
+ Event(const Event&) = delete;
+ Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
+ Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
+ operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
+ ~Event() { Event_free(self); }
+ Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
+ LDKEvent* operator &() { return &self; }
+ LDKEvent* operator ->() { return &self; }
+ const LDKEvent* operator &() const { return &self; }
+ const LDKEvent* operator ->() const { return &self; }
+};
+class MessageSendEvent {
+private:
+ LDKMessageSendEvent self;
+public:
+ MessageSendEvent(const MessageSendEvent&) = delete;
+ MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
+ MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
+ operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
+ ~MessageSendEvent() { MessageSendEvent_free(self); }
+ MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
+ LDKMessageSendEvent* operator &() { return &self; }
+ LDKMessageSendEvent* operator ->() { return &self; }
+ const LDKMessageSendEvent* operator &() const { return &self; }
+ const LDKMessageSendEvent* operator ->() const { return &self; }
+};
+class MessageSendEventsProvider {
+private:
+ LDKMessageSendEventsProvider self;
+public:
+ MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
+ MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
+ MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
+ operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
+ ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
+ MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
+ LDKMessageSendEventsProvider* operator &() { return &self; }
+ LDKMessageSendEventsProvider* operator ->() { return &self; }
+ const LDKMessageSendEventsProvider* operator &() const { return &self; }
+ const LDKMessageSendEventsProvider* operator ->() const { return &self; }
+ /**
+ * Gets the list of pending events which were generated by previous actions, clearing the list
+ * in the process.
+ */
+ inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
+};
+class EventsProvider {
+private:
+ LDKEventsProvider self;
+public:
+ EventsProvider(const EventsProvider&) = delete;
+ EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
+ EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
+ operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
+ ~EventsProvider() { EventsProvider_free(self); }
+ EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
+ LDKEventsProvider* operator &() { return &self; }
+ LDKEventsProvider* operator ->() { return &self; }
+ const LDKEventsProvider* operator &() const { return &self; }
+ const LDKEventsProvider* operator ->() const { return &self; }
+ /**
+ * Processes any events generated since the last call using the given event handler.
+ *
+ * See the trait-level documentation for requirements.
+ */
+ inline void process_pending_events(struct LDKEventHandler handler);
+};
+class ReplayEvent {
+private:
+ LDKReplayEvent self;
+public:
+ ReplayEvent(const ReplayEvent&) = delete;
+ ReplayEvent(ReplayEvent&& o) : self(o.self) { memset(&o, 0, sizeof(ReplayEvent)); }
+ ReplayEvent(LDKReplayEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplayEvent)); }
+ operator LDKReplayEvent() && { LDKReplayEvent res = self; memset(&self, 0, sizeof(LDKReplayEvent)); return res; }
+ ~ReplayEvent() { ReplayEvent_free(self); }
+ ReplayEvent& operator=(ReplayEvent&& o) { ReplayEvent_free(self); self = o.self; memset(&o, 0, sizeof(ReplayEvent)); return *this; }
+ LDKReplayEvent* operator &() { return &self; }
+ LDKReplayEvent* operator ->() { return &self; }
+ const LDKReplayEvent* operator &() const { return &self; }
+ const LDKReplayEvent* operator ->() const { return &self; }
+};
+class EventHandler {
+private:
+ LDKEventHandler self;
+public:
+ EventHandler(const EventHandler&) = delete;
+ EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
+ EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
+ operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
+ ~EventHandler() { EventHandler_free(self); }
+ EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
+ LDKEventHandler* operator &() { return &self; }
+ LDKEventHandler* operator ->() { return &self; }
+ const LDKEventHandler* operator &() const { return &self; }
+ const LDKEventHandler* operator ->() const { return &self; }
+ /**
+ * Handles the given [`Event`].
+ *
+ * See [`EventsProvider`] for details that must be considered when implementing this method.
+ */
+ inline LDK::CResult_NoneReplayEventZ handle_event(struct LDKEvent event);
+};
+class Nonce {
+private:
+ LDKNonce self;
+public:
+ Nonce(const Nonce&) = delete;
+ Nonce(Nonce&& o) : self(o.self) { memset(&o, 0, sizeof(Nonce)); }
+ Nonce(LDKNonce&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNonce)); }
+ operator LDKNonce() && { LDKNonce res = self; memset(&self, 0, sizeof(LDKNonce)); return res; }
+ ~Nonce() { Nonce_free(self); }
+ Nonce& operator=(Nonce&& o) { Nonce_free(self); self = o.self; memset(&o, 0, sizeof(Nonce)); return *this; }
+ LDKNonce* operator &() { return &self; }
+ LDKNonce* operator ->() { return &self; }
+ const LDKNonce* operator &() const { return &self; }
+ const LDKNonce* operator ->() const { return &self; }
+};
+class RoutingFees {
+private:
+ LDKRoutingFees self;
+public:
+ RoutingFees(const RoutingFees&) = delete;
+ RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
+ RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
+ operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
+ ~RoutingFees() { RoutingFees_free(self); }
+ RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
+ LDKRoutingFees* operator &() { return &self; }
+ LDKRoutingFees* operator ->() { return &self; }
+ const LDKRoutingFees* operator &() const { return &self; }
+ const LDKRoutingFees* operator ->() const { return &self; }
+};
+class RouteHint {
+private:
+ LDKRouteHint self;
+public:
+ RouteHint(const RouteHint&) = delete;
+ RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
+ RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
+ operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
+ ~RouteHint() { RouteHint_free(self); }
+ RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
+ LDKRouteHint* operator &() { return &self; }
+ LDKRouteHint* operator ->() { return &self; }
+ const LDKRouteHint* operator &() const { return &self; }
+ const LDKRouteHint* operator ->() const { return &self; }
+};
+class RouteHintHop {
+private:
+ LDKRouteHintHop self;
+public:
+ RouteHintHop(const RouteHintHop&) = delete;
+ RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
+ RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
+ operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
+ ~RouteHintHop() { RouteHintHop_free(self); }
+ RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
+ LDKRouteHintHop* operator &() { return &self; }
+ LDKRouteHintHop* operator ->() { return &self; }
+ const LDKRouteHintHop* operator &() const { return &self; }
+ const LDKRouteHintHop* operator ->() const { return &self; }
+};
+class Bolt11ParseError {
+private:
+ LDKBolt11ParseError self;
+public:
+ Bolt11ParseError(const Bolt11ParseError&) = delete;
+ Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
+ Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
+ operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
+ ~Bolt11ParseError() { Bolt11ParseError_free(self); }
+ Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
+ LDKBolt11ParseError* operator &() { return &self; }
+ LDKBolt11ParseError* operator ->() { return &self; }
+ const LDKBolt11ParseError* operator &() const { return &self; }
+ const LDKBolt11ParseError* operator ->() const { return &self; }
+};
+class ParseOrSemanticError {
+private:
+ LDKParseOrSemanticError self;
+public:
+ ParseOrSemanticError(const ParseOrSemanticError&) = delete;
+ ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
+ ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
+ operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
+ ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
+ ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
+ LDKParseOrSemanticError* operator &() { return &self; }
+ LDKParseOrSemanticError* operator ->() { return &self; }
+ const LDKParseOrSemanticError* operator &() const { return &self; }
+ const LDKParseOrSemanticError* operator ->() const { return &self; }
+};
+class Bolt11Invoice {
+private:
+ LDKBolt11Invoice self;
+public:
+ Bolt11Invoice(const Bolt11Invoice&) = delete;
+ Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
+ Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
+ operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
+ ~Bolt11Invoice() { Bolt11Invoice_free(self); }
+ Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
+ LDKBolt11Invoice* operator &() { return &self; }
+ LDKBolt11Invoice* operator ->() { return &self; }
+ const LDKBolt11Invoice* operator &() const { return &self; }
+ const LDKBolt11Invoice* operator ->() const { return &self; }
+};
+class SignedRawBolt11Invoice {
+private:
+ LDKSignedRawBolt11Invoice self;
+public:
+ SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
+ SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
+ SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
+ operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
+ ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
+ SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
+ LDKSignedRawBolt11Invoice* operator &() { return &self; }
+ LDKSignedRawBolt11Invoice* operator ->() { return &self; }
+ const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
+ const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
+};
+class RawBolt11Invoice {
+private:
+ LDKRawBolt11Invoice self;
+public:
+ RawBolt11Invoice(const RawBolt11Invoice&) = delete;
+ RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
+ RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
+ operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
+ ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
+ RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
+ LDKRawBolt11Invoice* operator &() { return &self; }
+ LDKRawBolt11Invoice* operator ->() { return &self; }
+ const LDKRawBolt11Invoice* operator &() const { return &self; }
+ const LDKRawBolt11Invoice* operator ->() const { return &self; }
+};
+class RawDataPart {
+private:
+ LDKRawDataPart self;
+public:
+ RawDataPart(const RawDataPart&) = delete;
+ RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
+ RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
+ operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
+ ~RawDataPart() { RawDataPart_free(self); }
+ RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
+ LDKRawDataPart* operator &() { return &self; }
+ LDKRawDataPart* operator ->() { return &self; }
+ const LDKRawDataPart* operator &() const { return &self; }
+ const LDKRawDataPart* operator ->() const { return &self; }
+};
+class PositiveTimestamp {
+private:
+ LDKPositiveTimestamp self;
+public:
+ PositiveTimestamp(const PositiveTimestamp&) = delete;
+ PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
+ PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
+ operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
+ ~PositiveTimestamp() { PositiveTimestamp_free(self); }
+ PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
+ LDKPositiveTimestamp* operator &() { return &self; }
+ LDKPositiveTimestamp* operator ->() { return &self; }
+ const LDKPositiveTimestamp* operator &() const { return &self; }
+ const LDKPositiveTimestamp* operator ->() const { return &self; }
+};
+class SiPrefix {
+private:
+ LDKSiPrefix self;
+public:
+ SiPrefix(const SiPrefix&) = delete;
+ SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
+ SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
+ operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
+ SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
+ LDKSiPrefix* operator &() { return &self; }
+ LDKSiPrefix* operator ->() { return &self; }
+ const LDKSiPrefix* operator &() const { return &self; }
+ const LDKSiPrefix* operator ->() const { return &self; }
+};
+class Currency {
+private:
+ LDKCurrency self;
+public:
+ Currency(const Currency&) = delete;
+ Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
+ Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
+ operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
+ Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
+ LDKCurrency* operator &() { return &self; }
+ LDKCurrency* operator ->() { return &self; }
+ const LDKCurrency* operator &() const { return &self; }
+ const LDKCurrency* operator ->() const { return &self; }
+};
+class Sha256 {
+private:
+ LDKSha256 self;
+public:
+ Sha256(const Sha256&) = delete;
+ Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
+ Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
+ operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
+ ~Sha256() { Sha256_free(self); }
+ Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
+ LDKSha256* operator &() { return &self; }
+ LDKSha256* operator ->() { return &self; }
+ const LDKSha256* operator &() const { return &self; }
+ const LDKSha256* operator ->() const { return &self; }
+};
+class Description {
+private:
+ LDKDescription self;
+public:
+ Description(const Description&) = delete;
+ Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
+ Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
+ operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
+ ~Description() { Description_free(self); }
+ Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
+ LDKDescription* operator &() { return &self; }
+ LDKDescription* operator ->() { return &self; }
+ const LDKDescription* operator &() const { return &self; }
+ const LDKDescription* operator ->() const { return &self; }
+};
+class PayeePubKey {
+private:
+ LDKPayeePubKey self;
+public:
+ PayeePubKey(const PayeePubKey&) = delete;
+ PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
+ PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
+ operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
+ ~PayeePubKey() { PayeePubKey_free(self); }
+ PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
+ LDKPayeePubKey* operator &() { return &self; }
+ LDKPayeePubKey* operator ->() { return &self; }
+ const LDKPayeePubKey* operator &() const { return &self; }
+ const LDKPayeePubKey* operator ->() const { return &self; }
+};
+class ExpiryTime {
+private:
+ LDKExpiryTime self;
+public:
+ ExpiryTime(const ExpiryTime&) = delete;
+ ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
+ ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
+ operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
+ ~ExpiryTime() { ExpiryTime_free(self); }
+ ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
+ LDKExpiryTime* operator &() { return &self; }
+ LDKExpiryTime* operator ->() { return &self; }
+ const LDKExpiryTime* operator &() const { return &self; }
+ const LDKExpiryTime* operator ->() const { return &self; }
+};
+class MinFinalCltvExpiryDelta {
+private:
+ LDKMinFinalCltvExpiryDelta self;
+public:
+ MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
+ MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
+ MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
+ operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
+ ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
+ MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
+ LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
+ LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
+ const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
+ const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
+};
+class Fallback {
+private:
+ LDKFallback self;
+public:
+ Fallback(const Fallback&) = delete;
+ Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
+ Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
+ operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
+ ~Fallback() { Fallback_free(self); }
+ Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
+ LDKFallback* operator &() { return &self; }
+ LDKFallback* operator ->() { return &self; }
+ const LDKFallback* operator &() const { return &self; }
+ const LDKFallback* operator ->() const { return &self; }
+};
+class Bolt11InvoiceSignature {
+private:
+ LDKBolt11InvoiceSignature self;
+public:
+ Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
+ Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
+ Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
+ operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
+ ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
+ Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
+ LDKBolt11InvoiceSignature* operator &() { return &self; }
+ LDKBolt11InvoiceSignature* operator ->() { return &self; }
+ const LDKBolt11InvoiceSignature* operator &() const { return &self; }
+ const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
+};
+class PrivateRoute {
+private:
+ LDKPrivateRoute self;
+public:
+ PrivateRoute(const PrivateRoute&) = delete;
+ PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
+ PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
+ operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
+ ~PrivateRoute() { PrivateRoute_free(self); }
+ PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
+ LDKPrivateRoute* operator &() { return &self; }
+ LDKPrivateRoute* operator ->() { return &self; }
+ const LDKPrivateRoute* operator &() const { return &self; }
+ const LDKPrivateRoute* operator ->() const { return &self; }
+};
+class CreationError {
+private:
+ LDKCreationError self;
+public:
+ CreationError(const CreationError&) = delete;
+ CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
+ CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
+ operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
+ CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
+ LDKCreationError* operator &() { return &self; }
+ LDKCreationError* operator ->() { return &self; }
+ const LDKCreationError* operator &() const { return &self; }
+ const LDKCreationError* operator ->() const { return &self; }
+};
+class Bolt11SemanticError {
+private:
+ LDKBolt11SemanticError self;
+public:
+ Bolt11SemanticError(const Bolt11SemanticError&) = delete;
+ Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
+ Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
+ operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
+ Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
+ LDKBolt11SemanticError* operator &() { return &self; }
+ LDKBolt11SemanticError* operator ->() { return &self; }
+ const LDKBolt11SemanticError* operator &() const { return &self; }
+ const LDKBolt11SemanticError* operator ->() const { return &self; }
+};
+class SignOrCreationError {
+private:
+ LDKSignOrCreationError self;
+public:
+ SignOrCreationError(const SignOrCreationError&) = delete;
+ SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
+ SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
+ operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
+ ~SignOrCreationError() { SignOrCreationError_free(self); }
+ SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
+ LDKSignOrCreationError* operator &() { return &self; }
+ LDKSignOrCreationError* operator ->() { return &self; }
+ const LDKSignOrCreationError* operator &() const { return &self; }
+ const LDKSignOrCreationError* operator ->() const { return &self; }
+};
+class OutPoint {
+private:
+ LDKOutPoint self;
+public:
+ OutPoint(const OutPoint&) = delete;
+ OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
+ OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
+ operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
+ ~OutPoint() { OutPoint_free(self); }
+ OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
+ LDKOutPoint* operator &() { return &self; }
+ LDKOutPoint* operator ->() { return &self; }
+ const LDKOutPoint* operator &() const { return &self; }
+ const LDKOutPoint* operator ->() const { return &self; }
+};
+class BigSize {
+private:
+ LDKBigSize self;
+public:
+ BigSize(const BigSize&) = delete;
+ BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
+ BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
+ operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
+ ~BigSize() { BigSize_free(self); }
+ BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
+ LDKBigSize* operator &() { return &self; }
+ LDKBigSize* operator ->() { return &self; }
+ const LDKBigSize* operator &() const { return &self; }
+ const LDKBigSize* operator ->() const { return &self; }
+};
+class Hostname {
+private:
+ LDKHostname self;
+public:
+ Hostname(const Hostname&) = delete;
+ Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
+ Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
+ operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
+ ~Hostname() { Hostname_free(self); }
+ Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
+ LDKHostname* operator &() { return &self; }
+ LDKHostname* operator ->() { return &self; }
+ const LDKHostname* operator &() const { return &self; }
+ const LDKHostname* operator ->() const { return &self; }
+};
+class TransactionU16LenLimited {
+private:
+ LDKTransactionU16LenLimited self;
+public:
+ TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
+ TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
+ TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
+ operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
+ ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
+ TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
+ LDKTransactionU16LenLimited* operator &() { return &self; }
+ LDKTransactionU16LenLimited* operator ->() { return &self; }
+ const LDKTransactionU16LenLimited* operator &() const { return &self; }
+ const LDKTransactionU16LenLimited* operator ->() const { return &self; }
+};
+class ChannelId {
+private:
+ LDKChannelId self;
+public:
+ ChannelId(const ChannelId&) = delete;
+ ChannelId(ChannelId&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelId)); }
+ ChannelId(LDKChannelId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelId)); }
+ operator LDKChannelId() && { LDKChannelId res = self; memset(&self, 0, sizeof(LDKChannelId)); return res; }
+ ~ChannelId() { ChannelId_free(self); }
+ ChannelId& operator=(ChannelId&& o) { ChannelId_free(self); self = o.self; memset(&o, 0, sizeof(ChannelId)); return *this; }
+ LDKChannelId* operator &() { return &self; }
+ LDKChannelId* operator ->() { return &self; }
+ const LDKChannelId* operator &() const { return &self; }
+ const LDKChannelId* 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 BlindedPayInfo {
+private:
+ LDKBlindedPayInfo self;
+public:
+ BlindedPayInfo(const BlindedPayInfo&) = delete;
+ BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
+ BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
+ operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
+ ~BlindedPayInfo() { BlindedPayInfo_free(self); }
+ BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
+ LDKBlindedPayInfo* operator &() { return &self; }
+ LDKBlindedPayInfo* operator ->() { return &self; }
+ const LDKBlindedPayInfo* operator &() const { return &self; }
+ const LDKBlindedPayInfo* operator ->() const { return &self; }
+};
+class BlindedPaymentPath {
+private:
+ LDKBlindedPaymentPath self;
+public:
+ BlindedPaymentPath(const BlindedPaymentPath&) = delete;
+ BlindedPaymentPath(BlindedPaymentPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPaymentPath)); }
+ BlindedPaymentPath(LDKBlindedPaymentPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPaymentPath)); }
+ operator LDKBlindedPaymentPath() && { LDKBlindedPaymentPath res = self; memset(&self, 0, sizeof(LDKBlindedPaymentPath)); return res; }
+ ~BlindedPaymentPath() { BlindedPaymentPath_free(self); }
+ BlindedPaymentPath& operator=(BlindedPaymentPath&& o) { BlindedPaymentPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPaymentPath)); return *this; }
+ LDKBlindedPaymentPath* operator &() { return &self; }
+ LDKBlindedPaymentPath* operator ->() { return &self; }
+ const LDKBlindedPaymentPath* operator &() const { return &self; }
+ const LDKBlindedPaymentPath* operator ->() const { return &self; }
+};
+class PaymentForwardNode {
+private:
+ LDKPaymentForwardNode self;
+public:
+ PaymentForwardNode(const PaymentForwardNode&) = delete;
+ PaymentForwardNode(PaymentForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentForwardNode)); }
+ PaymentForwardNode(LDKPaymentForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentForwardNode)); }
+ operator LDKPaymentForwardNode() && { LDKPaymentForwardNode res = self; memset(&self, 0, sizeof(LDKPaymentForwardNode)); return res; }
+ ~PaymentForwardNode() { PaymentForwardNode_free(self); }
+ PaymentForwardNode& operator=(PaymentForwardNode&& o) { PaymentForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(PaymentForwardNode)); return *this; }
+ LDKPaymentForwardNode* operator &() { return &self; }
+ LDKPaymentForwardNode* operator ->() { return &self; }
+ const LDKPaymentForwardNode* operator &() const { return &self; }
+ const LDKPaymentForwardNode* operator ->() const { return &self; }
+};
+class ForwardTlvs {
+private:
+ LDKForwardTlvs self;
+public:
+ ForwardTlvs(const ForwardTlvs&) = delete;
+ ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
+ ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
+ operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
+ ~ForwardTlvs() { ForwardTlvs_free(self); }
+ ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
+ LDKForwardTlvs* operator &() { return &self; }
+ LDKForwardTlvs* operator ->() { return &self; }
+ const LDKForwardTlvs* operator &() const { return &self; }
+ const LDKForwardTlvs* operator ->() const { return &self; }
+};
+class ReceiveTlvs {
+private:
+ LDKReceiveTlvs self;
+public:
+ ReceiveTlvs(const ReceiveTlvs&) = delete;
+ ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
+ ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
+ operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
+ ~ReceiveTlvs() { ReceiveTlvs_free(self); }
+ ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
+ LDKReceiveTlvs* operator &() { return &self; }
+ LDKReceiveTlvs* operator ->() { return &self; }
+ const LDKReceiveTlvs* operator &() const { return &self; }
+ const LDKReceiveTlvs* operator ->() const { return &self; }
+};
+class PaymentRelay {
+private:
+ LDKPaymentRelay self;
+public:
+ PaymentRelay(const PaymentRelay&) = delete;
+ PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
+ PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
+ operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
+ ~PaymentRelay() { PaymentRelay_free(self); }
+ PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
+ LDKPaymentRelay* operator &() { return &self; }
+ LDKPaymentRelay* operator ->() { return &self; }
+ const LDKPaymentRelay* operator &() const { return &self; }
+ const LDKPaymentRelay* operator ->() const { return &self; }
+};
+class PaymentConstraints {
+private:
+ LDKPaymentConstraints self;
+public:
+ PaymentConstraints(const PaymentConstraints&) = delete;
+ PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
+ PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
+ operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
+ ~PaymentConstraints() { PaymentConstraints_free(self); }
+ PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
+ LDKPaymentConstraints* operator &() { return &self; }
+ LDKPaymentConstraints* operator ->() { return &self; }
+ const LDKPaymentConstraints* operator &() const { return &self; }
+ const LDKPaymentConstraints* operator ->() const { return &self; }
+};
+class PaymentContext {
+private:
+ LDKPaymentContext self;
+public:
+ PaymentContext(const PaymentContext&) = delete;
+ PaymentContext(PaymentContext&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentContext)); }
+ PaymentContext(LDKPaymentContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentContext)); }
+ operator LDKPaymentContext() && { LDKPaymentContext res = self; memset(&self, 0, sizeof(LDKPaymentContext)); return res; }
+ ~PaymentContext() { PaymentContext_free(self); }
+ PaymentContext& operator=(PaymentContext&& o) { PaymentContext_free(self); self = o.self; memset(&o, 0, sizeof(PaymentContext)); return *this; }
+ LDKPaymentContext* operator &() { return &self; }
+ LDKPaymentContext* operator ->() { return &self; }
+ const LDKPaymentContext* operator &() const { return &self; }
+ const LDKPaymentContext* operator ->() const { return &self; }
+};
+class UnknownPaymentContext {
+private:
+ LDKUnknownPaymentContext self;
+public:
+ UnknownPaymentContext(const UnknownPaymentContext&) = delete;
+ UnknownPaymentContext(UnknownPaymentContext&& o) : self(o.self) { memset(&o, 0, sizeof(UnknownPaymentContext)); }
+ UnknownPaymentContext(LDKUnknownPaymentContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnknownPaymentContext)); }
+ operator LDKUnknownPaymentContext() && { LDKUnknownPaymentContext res = self; memset(&self, 0, sizeof(LDKUnknownPaymentContext)); return res; }
+ ~UnknownPaymentContext() { UnknownPaymentContext_free(self); }
+ UnknownPaymentContext& operator=(UnknownPaymentContext&& o) { UnknownPaymentContext_free(self); self = o.self; memset(&o, 0, sizeof(UnknownPaymentContext)); return *this; }
+ LDKUnknownPaymentContext* operator &() { return &self; }
+ LDKUnknownPaymentContext* operator ->() { return &self; }
+ const LDKUnknownPaymentContext* operator &() const { return &self; }
+ const LDKUnknownPaymentContext* operator ->() const { return &self; }
+};
+class Bolt12OfferContext {
+private:
+ LDKBolt12OfferContext self;
+public:
+ Bolt12OfferContext(const Bolt12OfferContext&) = delete;
+ Bolt12OfferContext(Bolt12OfferContext&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12OfferContext)); }
+ Bolt12OfferContext(LDKBolt12OfferContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12OfferContext)); }
+ operator LDKBolt12OfferContext() && { LDKBolt12OfferContext res = self; memset(&self, 0, sizeof(LDKBolt12OfferContext)); return res; }
+ ~Bolt12OfferContext() { Bolt12OfferContext_free(self); }
+ Bolt12OfferContext& operator=(Bolt12OfferContext&& o) { Bolt12OfferContext_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12OfferContext)); return *this; }
+ LDKBolt12OfferContext* operator &() { return &self; }
+ LDKBolt12OfferContext* operator ->() { return &self; }
+ const LDKBolt12OfferContext* operator &() const { return &self; }
+ const LDKBolt12OfferContext* operator ->() const { return &self; }
+};
+class Bolt12RefundContext {
+private:
+ LDKBolt12RefundContext self;
+public:
+ Bolt12RefundContext(const Bolt12RefundContext&) = delete;
+ Bolt12RefundContext(Bolt12RefundContext&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12RefundContext)); }
+ Bolt12RefundContext(LDKBolt12RefundContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12RefundContext)); }
+ operator LDKBolt12RefundContext() && { LDKBolt12RefundContext res = self; memset(&self, 0, sizeof(LDKBolt12RefundContext)); return res; }
+ ~Bolt12RefundContext() { Bolt12RefundContext_free(self); }
+ Bolt12RefundContext& operator=(Bolt12RefundContext&& o) { Bolt12RefundContext_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12RefundContext)); return *this; }
+ LDKBolt12RefundContext* operator &() { return &self; }
+ LDKBolt12RefundContext* operator ->() { return &self; }
+ const LDKBolt12RefundContext* operator &() const { return &self; }
+ const LDKBolt12RefundContext* operator ->() const { return &self; }
+};
+class UtxoLookupError {
+private:
+ LDKUtxoLookupError self;
+public:
+ UtxoLookupError(const UtxoLookupError&) = delete;
+ UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
+ UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
+ operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
+ UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
+ LDKUtxoLookupError* operator &() { return &self; }
+ LDKUtxoLookupError* operator ->() { return &self; }
+ const LDKUtxoLookupError* operator &() const { return &self; }
+ const LDKUtxoLookupError* operator ->() const { return &self; }
+};
+class UtxoResult {
+private:
+ LDKUtxoResult self;
+public:
+ UtxoResult(const UtxoResult&) = delete;
+ UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
+ UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
+ operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
+ ~UtxoResult() { UtxoResult_free(self); }
+ UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
+ LDKUtxoResult* operator &() { return &self; }
+ LDKUtxoResult* operator ->() { return &self; }
+ const LDKUtxoResult* operator &() const { return &self; }
+ const LDKUtxoResult* operator ->() const { return &self; }
+};
+class UtxoLookup {
+private:
+ LDKUtxoLookup self;
+public:
+ UtxoLookup(const UtxoLookup&) = delete;
+ UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
+ UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
+ operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
+ ~UtxoLookup() { UtxoLookup_free(self); }
+ UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
+ LDKUtxoLookup* operator &() { return &self; }
+ LDKUtxoLookup* operator ->() { return &self; }
+ const LDKUtxoLookup* operator &() const { return &self; }
+ const LDKUtxoLookup* operator ->() const { return &self; }
+ /**
+ * Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
+ * Returns an error if `chain_hash` is for a different chain or if such a transaction output is
+ * unknown.
+ *
+ * [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
+ */
+ inline LDK::UtxoResult get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id);
+};
+class UtxoFuture {
+private:
+ LDKUtxoFuture self;
+public:
+ UtxoFuture(const UtxoFuture&) = delete;
+ UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
+ UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
+ operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
+ ~UtxoFuture() { UtxoFuture_free(self); }
+ UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
+ LDKUtxoFuture* operator &() { return &self; }
+ LDKUtxoFuture* operator ->() { return &self; }
+ const LDKUtxoFuture* operator &() const { return &self; }
+ const LDKUtxoFuture* operator ->() const { return &self; }
+};
+class OnionMessenger {
+private:
+ LDKOnionMessenger self;
+public:
+ OnionMessenger(const OnionMessenger&) = delete;
+ OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
+ OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
+ operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
+ ~OnionMessenger() { OnionMessenger_free(self); }
+ OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
+ LDKOnionMessenger* operator &() { return &self; }
+ LDKOnionMessenger* operator ->() { return &self; }
+ const LDKOnionMessenger* operator &() const { return &self; }
+ const LDKOnionMessenger* operator ->() const { return &self; }
+};
+class Responder {
+private:
+ LDKResponder self;
+public:
+ Responder(const Responder&) = delete;
+ Responder(Responder&& o) : self(o.self) { memset(&o, 0, sizeof(Responder)); }
+ Responder(LDKResponder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKResponder)); }
+ operator LDKResponder() && { LDKResponder res = self; memset(&self, 0, sizeof(LDKResponder)); return res; }
+ ~Responder() { Responder_free(self); }
+ Responder& operator=(Responder&& o) { Responder_free(self); self = o.self; memset(&o, 0, sizeof(Responder)); return *this; }
+ LDKResponder* operator &() { return &self; }
+ LDKResponder* operator ->() { return &self; }
+ const LDKResponder* operator &() const { return &self; }
+ const LDKResponder* operator ->() const { return &self; }
+};
+class ResponseInstruction {
+private:
+ LDKResponseInstruction self;
+public:
+ ResponseInstruction(const ResponseInstruction&) = delete;
+ ResponseInstruction(ResponseInstruction&& o) : self(o.self) { memset(&o, 0, sizeof(ResponseInstruction)); }
+ ResponseInstruction(LDKResponseInstruction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKResponseInstruction)); }
+ operator LDKResponseInstruction() && { LDKResponseInstruction res = self; memset(&self, 0, sizeof(LDKResponseInstruction)); return res; }
+ ~ResponseInstruction() { ResponseInstruction_free(self); }
+ ResponseInstruction& operator=(ResponseInstruction&& o) { ResponseInstruction_free(self); self = o.self; memset(&o, 0, sizeof(ResponseInstruction)); return *this; }
+ LDKResponseInstruction* operator &() { return &self; }
+ LDKResponseInstruction* operator ->() { return &self; }
+ const LDKResponseInstruction* operator &() const { return &self; }
+ const LDKResponseInstruction* operator ->() const { return &self; }
+};
+class MessageSendInstructions {
+private:
+ LDKMessageSendInstructions self;
+public:
+ MessageSendInstructions(const MessageSendInstructions&) = delete;
+ MessageSendInstructions(MessageSendInstructions&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendInstructions)); }
+ MessageSendInstructions(LDKMessageSendInstructions&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendInstructions)); }
+ operator LDKMessageSendInstructions() && { LDKMessageSendInstructions res = self; memset(&self, 0, sizeof(LDKMessageSendInstructions)); return res; }
+ ~MessageSendInstructions() { MessageSendInstructions_free(self); }
+ MessageSendInstructions& operator=(MessageSendInstructions&& o) { MessageSendInstructions_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendInstructions)); return *this; }
+ LDKMessageSendInstructions* operator &() { return &self; }
+ LDKMessageSendInstructions* operator ->() { return &self; }
+ const LDKMessageSendInstructions* operator &() const { return &self; }
+ const LDKMessageSendInstructions* operator ->() const { return &self; }
+};
+class MessageRouter {
+private:
+ LDKMessageRouter self;
+public:
+ MessageRouter(const MessageRouter&) = delete;
+ MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
+ MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
+ operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
+ ~MessageRouter() { MessageRouter_free(self); }
+ MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
+ LDKMessageRouter* operator &() { return &self; }
+ LDKMessageRouter* operator ->() { return &self; }
+ const LDKMessageRouter* operator &() const { return &self; }
+ const LDKMessageRouter* operator ->() const { return &self; }
+ /**
+ * Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
+ */
+ inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
+ /**
+ * Creates [`BlindedMessagePath`]s to the `recipient` node. The nodes in `peers` are assumed to
+ * be direct peers with the `recipient`.
+ */
+ inline LDK::CResult_CVec_BlindedMessagePathZNoneZ create_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_PublicKeyZ peers);
+ /**
+ * Creates compact [`BlindedMessagePath`]s to the `recipient` node. The nodes in `peers` are
+ * assumed to be direct peers with the `recipient`.
+ *
+ * Compact blinded paths use short channel ids instead of pubkeys for a smaller serialization,
+ * which is beneficial when a QR code is used to transport the data. The SCID is passed using
+ * a [`MessageForwardNode`] but may be `None` for graceful degradation.
+ *
+ * Implementations using additional intermediate nodes are responsible for using a
+ * [`MessageForwardNode`] with `Some` short channel id, if possible. Similarly, implementations
+ * should call [`BlindedMessagePath::use_compact_introduction_node`].
+ *
+ * The provided implementation simply delegates to [`MessageRouter::create_blinded_paths`],
+ * ignoring the short channel ids.
+ */
+ inline LDK::CResult_CVec_BlindedMessagePathZNoneZ create_compact_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_MessageForwardNodeZ peers);
+};
+class DefaultMessageRouter {
+private:
+ LDKDefaultMessageRouter self;
+public:
+ DefaultMessageRouter(const DefaultMessageRouter&) = delete;
+ DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
+ DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
+ operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
+ ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
+ DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
+ LDKDefaultMessageRouter* operator &() { return &self; }
+ LDKDefaultMessageRouter* operator ->() { return &self; }
+ const LDKDefaultMessageRouter* operator &() const { return &self; }
+ const LDKDefaultMessageRouter* operator ->() const { return &self; }
+};
+class OnionMessagePath {
+private:
+ LDKOnionMessagePath self;
+public:
+ OnionMessagePath(const OnionMessagePath&) = delete;
+ OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
+ OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
+ operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
+ ~OnionMessagePath() { OnionMessagePath_free(self); }
+ OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
+ LDKOnionMessagePath* operator &() { return &self; }
+ LDKOnionMessagePath* operator ->() { return &self; }
+ const LDKOnionMessagePath* operator &() const { return &self; }
+ const LDKOnionMessagePath* operator ->() const { return &self; }
+};
+class Destination {
+private:
+ LDKDestination self;
+public:
+ Destination(const Destination&) = delete;
+ Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
+ Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
+ operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
+ ~Destination() { Destination_free(self); }
+ Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
+ LDKDestination* operator &() { return &self; }
+ LDKDestination* operator ->() { return &self; }
+ const LDKDestination* operator &() const { return &self; }
+ const LDKDestination* operator ->() const { return &self; }
+};
+class SendSuccess {
+private:
+ LDKSendSuccess self;
+public:
+ SendSuccess(const SendSuccess&) = delete;
+ SendSuccess(SendSuccess&& o) : self(o.self) { memset(&o, 0, sizeof(SendSuccess)); }
+ SendSuccess(LDKSendSuccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendSuccess)); }
+ operator LDKSendSuccess() && { LDKSendSuccess res = self; memset(&self, 0, sizeof(LDKSendSuccess)); return res; }
+ ~SendSuccess() { SendSuccess_free(self); }
+ SendSuccess& operator=(SendSuccess&& o) { SendSuccess_free(self); self = o.self; memset(&o, 0, sizeof(SendSuccess)); return *this; }
+ LDKSendSuccess* operator &() { return &self; }
+ LDKSendSuccess* operator ->() { return &self; }
+ const LDKSendSuccess* operator &() const { return &self; }
+ const LDKSendSuccess* operator ->() const { return &self; }
+};
+class SendError {
+private:
+ LDKSendError self;
+public:
+ SendError(const SendError&) = delete;
+ SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
+ SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
+ operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
+ ~SendError() { SendError_free(self); }
+ SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
+ LDKSendError* operator &() { return &self; }
+ LDKSendError* operator ->() { return &self; }
+ const LDKSendError* operator &() const { return &self; }
+ const LDKSendError* operator ->() const { return &self; }
+};
+class CustomOnionMessageHandler {
+private:
+ LDKCustomOnionMessageHandler self;
+public:
+ CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
+ CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
+ CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
+ operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
+ ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
+ CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
+ LDKCustomOnionMessageHandler* operator &() { return &self; }
+ LDKCustomOnionMessageHandler* operator ->() { return &self; }
+ const LDKCustomOnionMessageHandler* operator &() const { return &self; }
+ const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
+ /**
+ * Called with the custom message that was received, returning a response to send, if any.
+ *
+ * The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_OnionMessageContentsResponseInstructionZZ handle_custom_message(struct LDKOnionMessageContents message, struct LDKCOption_CVec_u8ZZ context, struct LDKResponder responder);
+ /**
+ * Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
+ * message type is unknown.
+ */
+ inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
+ /**
+ * Releases any [`Self::CustomMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating a message flow rather than in response to
+ * another message. The latter should use the return value of [`Self::handle_custom_message`].
+ */
+ inline LDK::CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ release_pending_custom_messages();
+};
+class PeeledOnion {
+private:
+ LDKPeeledOnion self;
+public:
+ PeeledOnion(const PeeledOnion&) = delete;
+ PeeledOnion(PeeledOnion&& o) : self(o.self) { memset(&o, 0, sizeof(PeeledOnion)); }
+ PeeledOnion(LDKPeeledOnion&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeeledOnion)); }
+ operator LDKPeeledOnion() && { LDKPeeledOnion res = self; memset(&self, 0, sizeof(LDKPeeledOnion)); return res; }
+ ~PeeledOnion() { PeeledOnion_free(self); }
+ PeeledOnion& operator=(PeeledOnion&& o) { PeeledOnion_free(self); self = o.self; memset(&o, 0, sizeof(PeeledOnion)); return *this; }
+ LDKPeeledOnion* operator &() { return &self; }
+ LDKPeeledOnion* operator ->() { return &self; }
+ const LDKPeeledOnion* operator &() const { return &self; }
+ const LDKPeeledOnion* operator ->() const { return &self; }
+};
+class FilesystemStore {
+private:
+ LDKFilesystemStore self;
+public:
+ FilesystemStore(const FilesystemStore&) = delete;
+ FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
+ FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
+ operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
+ ~FilesystemStore() { FilesystemStore_free(self); }
+ FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
+ LDKFilesystemStore* operator &() { return &self; }
+ LDKFilesystemStore* operator ->() { return &self; }
+ const LDKFilesystemStore* operator &() const { return &self; }
+ const LDKFilesystemStore* operator ->() const { return &self; }
+};
+class InitFeatures {
+private:
+ LDKInitFeatures self;
+public:
+ InitFeatures(const InitFeatures&) = delete;
+ InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
+ InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
+ operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
+ ~InitFeatures() { InitFeatures_free(self); }
+ InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
+ LDKInitFeatures* operator &() { return &self; }
+ LDKInitFeatures* operator ->() { return &self; }
+ const LDKInitFeatures* operator &() const { return &self; }
+ const LDKInitFeatures* operator ->() const { return &self; }
+};
+class NodeFeatures {
+private:
+ LDKNodeFeatures self;
+public:
+ NodeFeatures(const NodeFeatures&) = delete;
+ NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
+ NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
+ operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
+ ~NodeFeatures() { NodeFeatures_free(self); }
+ NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
+ LDKNodeFeatures* operator &() { return &self; }
+ LDKNodeFeatures* operator ->() { return &self; }
+ const LDKNodeFeatures* operator &() const { return &self; }
+ const LDKNodeFeatures* operator ->() const { return &self; }
+};
+class ChannelFeatures {
+private:
+ LDKChannelFeatures self;
+public:
+ ChannelFeatures(const ChannelFeatures&) = delete;
+ ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
+ ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
+ operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
+ ~ChannelFeatures() { ChannelFeatures_free(self); }
+ ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
+ LDKChannelFeatures* operator &() { return &self; }
+ LDKChannelFeatures* operator ->() { return &self; }
+ const LDKChannelFeatures* operator &() const { return &self; }
+ const LDKChannelFeatures* operator ->() const { return &self; }
+};
+class Bolt11InvoiceFeatures {
+private:
+ LDKBolt11InvoiceFeatures self;
+public:
+ Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
+ Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
+ Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
+ operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
+ ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
+ Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
+ LDKBolt11InvoiceFeatures* operator &() { return &self; }
+ LDKBolt11InvoiceFeatures* operator ->() { return &self; }
+ const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
+ const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
+};
+class OfferFeatures {
+private:
+ LDKOfferFeatures self;
+public:
+ OfferFeatures(const OfferFeatures&) = delete;
+ OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
+ OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
+ operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
+ ~OfferFeatures() { OfferFeatures_free(self); }
+ OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
+ LDKOfferFeatures* operator &() { return &self; }
+ LDKOfferFeatures* operator ->() { return &self; }
+ const LDKOfferFeatures* operator &() const { return &self; }
+ const LDKOfferFeatures* operator ->() const { return &self; }
+};
+class InvoiceRequestFeatures {
+private:
+ LDKInvoiceRequestFeatures self;
+public:
+ InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
+ InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
+ InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
+ operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
+ ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
+ InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
+ LDKInvoiceRequestFeatures* operator &() { return &self; }
+ LDKInvoiceRequestFeatures* operator ->() { return &self; }
+ const LDKInvoiceRequestFeatures* operator &() const { return &self; }
+ const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
+};
+class Bolt12InvoiceFeatures {
+private:
+ LDKBolt12InvoiceFeatures self;
+public:
+ Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
+ Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
+ Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
+ operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
+ ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
+ Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
+ LDKBolt12InvoiceFeatures* operator &() { return &self; }
+ LDKBolt12InvoiceFeatures* operator ->() { return &self; }
+ const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
+ const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
+};
+class BlindedHopFeatures {
+private:
+ LDKBlindedHopFeatures self;
+public:
+ BlindedHopFeatures(const BlindedHopFeatures&) = delete;
+ BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
+ BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
+ operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
+ ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
+ BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
+ LDKBlindedHopFeatures* operator &() { return &self; }
+ LDKBlindedHopFeatures* operator ->() { return &self; }
+ const LDKBlindedHopFeatures* operator &() const { return &self; }
+ const LDKBlindedHopFeatures* operator ->() const { return &self; }
+};
+class ChannelTypeFeatures {
+private:
+ LDKChannelTypeFeatures self;
+public:
+ ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
+ ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
+ ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
+ operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
+ ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
+ ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
+ LDKChannelTypeFeatures* operator &() { return &self; }
+ LDKChannelTypeFeatures* operator ->() { return &self; }
+ const LDKChannelTypeFeatures* operator &() const { return &self; }
+ const LDKChannelTypeFeatures* operator ->() const { return &self; }
+};
+class IntroductionNode {
+private:
+ LDKIntroductionNode self;
+public:
+ IntroductionNode(const IntroductionNode&) = delete;
+ IntroductionNode(IntroductionNode&& o) : self(o.self) { memset(&o, 0, sizeof(IntroductionNode)); }
+ IntroductionNode(LDKIntroductionNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIntroductionNode)); }
+ operator LDKIntroductionNode() && { LDKIntroductionNode res = self; memset(&self, 0, sizeof(LDKIntroductionNode)); return res; }
+ ~IntroductionNode() { IntroductionNode_free(self); }
+ IntroductionNode& operator=(IntroductionNode&& o) { IntroductionNode_free(self); self = o.self; memset(&o, 0, sizeof(IntroductionNode)); return *this; }
+ LDKIntroductionNode* operator &() { return &self; }
+ LDKIntroductionNode* operator ->() { return &self; }
+ const LDKIntroductionNode* operator &() const { return &self; }
+ const LDKIntroductionNode* operator ->() const { return &self; }
+};
+class Direction {
+private:
+ LDKDirection self;
+public:
+ Direction(const Direction&) = delete;
+ Direction(Direction&& o) : self(o.self) { memset(&o, 0, sizeof(Direction)); }
+ Direction(LDKDirection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirection)); }
+ operator LDKDirection() && { LDKDirection res = self; memset(&self, 0, sizeof(LDKDirection)); return res; }
+ Direction& operator=(Direction&& o) { self = o.self; memset(&o, 0, sizeof(Direction)); return *this; }
+ LDKDirection* operator &() { return &self; }
+ LDKDirection* operator ->() { return &self; }
+ const LDKDirection* operator &() const { return &self; }
+ const LDKDirection* operator ->() const { return &self; }
+};
+class NodeIdLookUp {
+private:
+ LDKNodeIdLookUp self;
+public:
+ NodeIdLookUp(const NodeIdLookUp&) = delete;
+ NodeIdLookUp(NodeIdLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(NodeIdLookUp)); }
+ NodeIdLookUp(LDKNodeIdLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeIdLookUp)); }
+ operator LDKNodeIdLookUp() && { LDKNodeIdLookUp res = self; memset(&self, 0, sizeof(LDKNodeIdLookUp)); return res; }
+ ~NodeIdLookUp() { NodeIdLookUp_free(self); }
+ NodeIdLookUp& operator=(NodeIdLookUp&& o) { NodeIdLookUp_free(self); self = o.self; memset(&o, 0, sizeof(NodeIdLookUp)); return *this; }
+ LDKNodeIdLookUp* operator &() { return &self; }
+ LDKNodeIdLookUp* operator ->() { return &self; }
+ const LDKNodeIdLookUp* operator &() const { return &self; }
+ const LDKNodeIdLookUp* operator ->() const { return &self; }
+ /**
+ * Returns the node id of the forwarding node's channel counterparty with `short_channel_id`.
+ *
+ * Here, the forwarding node is referring to the node of the [`OnionMessenger`] parameterized
+ * by the [`NodeIdLookUp`] and the counterparty to one of that node's peers.
+ *
+ * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
+ *
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDKPublicKey next_node_id(uint64_t short_channel_id);
+};
+class EmptyNodeIdLookUp {
+private:
+ LDKEmptyNodeIdLookUp self;
+public:
+ EmptyNodeIdLookUp(const EmptyNodeIdLookUp&) = delete;
+ EmptyNodeIdLookUp(EmptyNodeIdLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(EmptyNodeIdLookUp)); }
+ EmptyNodeIdLookUp(LDKEmptyNodeIdLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEmptyNodeIdLookUp)); }
+ operator LDKEmptyNodeIdLookUp() && { LDKEmptyNodeIdLookUp res = self; memset(&self, 0, sizeof(LDKEmptyNodeIdLookUp)); return res; }
+ ~EmptyNodeIdLookUp() { EmptyNodeIdLookUp_free(self); }
+ EmptyNodeIdLookUp& operator=(EmptyNodeIdLookUp&& o) { EmptyNodeIdLookUp_free(self); self = o.self; memset(&o, 0, sizeof(EmptyNodeIdLookUp)); return *this; }
+ LDKEmptyNodeIdLookUp* operator &() { return &self; }
+ LDKEmptyNodeIdLookUp* operator ->() { return &self; }
+ const LDKEmptyNodeIdLookUp* operator &() const { return &self; }
+ const LDKEmptyNodeIdLookUp* operator ->() const { return &self; }
+};
+class BlindedHop {
+private:
+ LDKBlindedHop self;
+public:
+ BlindedHop(const BlindedHop&) = delete;
+ BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
+ BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
+ operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
+ ~BlindedHop() { BlindedHop_free(self); }
+ BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
+ LDKBlindedHop* operator &() { return &self; }
+ LDKBlindedHop* operator ->() { return &self; }
+ const LDKBlindedHop* operator &() const { return &self; }
+ const LDKBlindedHop* operator ->() const { return &self; }
+};
+class InvoiceError {
+private:
+ LDKInvoiceError self;
+public:
+ InvoiceError(const InvoiceError&) = delete;
+ InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
+ InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
+ operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
+ ~InvoiceError() { InvoiceError_free(self); }
+ InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
+ LDKInvoiceError* operator &() { return &self; }
+ LDKInvoiceError* operator ->() { return &self; }
+ const LDKInvoiceError* operator &() const { return &self; }
+ const LDKInvoiceError* operator ->() const { return &self; }
+};
+class ErroneousField {
+private:
+ LDKErroneousField self;
+public:
+ ErroneousField(const ErroneousField&) = delete;
+ ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
+ ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
+ operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
+ ~ErroneousField() { ErroneousField_free(self); }
+ ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
+ LDKErroneousField* operator &() { return &self; }
+ LDKErroneousField* operator ->() { return &self; }
+ const LDKErroneousField* operator &() const { return &self; }
+ const LDKErroneousField* operator ->() const { return &self; }
+};
+class TrackedSpendableOutput {
+private:
+ LDKTrackedSpendableOutput self;
+public:
+ TrackedSpendableOutput(const TrackedSpendableOutput&) = delete;
+ TrackedSpendableOutput(TrackedSpendableOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TrackedSpendableOutput)); }
+ TrackedSpendableOutput(LDKTrackedSpendableOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrackedSpendableOutput)); }
+ operator LDKTrackedSpendableOutput() && { LDKTrackedSpendableOutput res = self; memset(&self, 0, sizeof(LDKTrackedSpendableOutput)); return res; }
+ ~TrackedSpendableOutput() { TrackedSpendableOutput_free(self); }
+ TrackedSpendableOutput& operator=(TrackedSpendableOutput&& o) { TrackedSpendableOutput_free(self); self = o.self; memset(&o, 0, sizeof(TrackedSpendableOutput)); return *this; }
+ LDKTrackedSpendableOutput* operator &() { return &self; }
+ LDKTrackedSpendableOutput* operator ->() { return &self; }
+ const LDKTrackedSpendableOutput* operator &() const { return &self; }
+ const LDKTrackedSpendableOutput* operator ->() const { return &self; }
+};
+class OutputSpendStatus {
+private:
+ LDKOutputSpendStatus self;
+public:
+ OutputSpendStatus(const OutputSpendStatus&) = delete;
+ OutputSpendStatus(OutputSpendStatus&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpendStatus)); }
+ OutputSpendStatus(LDKOutputSpendStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpendStatus)); }
+ operator LDKOutputSpendStatus() && { LDKOutputSpendStatus res = self; memset(&self, 0, sizeof(LDKOutputSpendStatus)); return res; }
+ ~OutputSpendStatus() { OutputSpendStatus_free(self); }
+ OutputSpendStatus& operator=(OutputSpendStatus&& o) { OutputSpendStatus_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpendStatus)); return *this; }
+ LDKOutputSpendStatus* operator &() { return &self; }
+ LDKOutputSpendStatus* operator ->() { return &self; }
+ const LDKOutputSpendStatus* operator &() const { return &self; }
+ const LDKOutputSpendStatus* operator ->() const { return &self; }
+};
+class OutputSweeper {
+private:
+ LDKOutputSweeper self;
+public:
+ OutputSweeper(const OutputSweeper&) = delete;
+ OutputSweeper(OutputSweeper&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSweeper)); }
+ OutputSweeper(LDKOutputSweeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSweeper)); }
+ operator LDKOutputSweeper() && { LDKOutputSweeper res = self; memset(&self, 0, sizeof(LDKOutputSweeper)); return res; }
+ ~OutputSweeper() { OutputSweeper_free(self); }
+ OutputSweeper& operator=(OutputSweeper&& o) { OutputSweeper_free(self); self = o.self; memset(&o, 0, sizeof(OutputSweeper)); return *this; }
+ LDKOutputSweeper* operator &() { return &self; }
+ LDKOutputSweeper* operator ->() { return &self; }
+ const LDKOutputSweeper* operator &() const { return &self; }
+ const LDKOutputSweeper* operator ->() const { return &self; }
+};
+class SpendingDelay {
+private:
+ LDKSpendingDelay self;
+public:
+ SpendingDelay(const SpendingDelay&) = delete;
+ SpendingDelay(SpendingDelay&& o) : self(o.self) { memset(&o, 0, sizeof(SpendingDelay)); }
+ SpendingDelay(LDKSpendingDelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendingDelay)); }
+ operator LDKSpendingDelay() && { LDKSpendingDelay res = self; memset(&self, 0, sizeof(LDKSpendingDelay)); return res; }
+ ~SpendingDelay() { SpendingDelay_free(self); }
+ SpendingDelay& operator=(SpendingDelay&& o) { SpendingDelay_free(self); self = o.self; memset(&o, 0, sizeof(SpendingDelay)); return *this; }
+ LDKSpendingDelay* operator &() { return &self; }
+ LDKSpendingDelay* operator ->() { return &self; }
+ const LDKSpendingDelay* operator &() const { return &self; }
+ const LDKSpendingDelay* operator ->() const { return &self; }
+};
+class DelayedPaymentBasepoint {
+private:
+ LDKDelayedPaymentBasepoint self;
+public:
+ DelayedPaymentBasepoint(const DelayedPaymentBasepoint&) = delete;
+ DelayedPaymentBasepoint(DelayedPaymentBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentBasepoint)); }
+ DelayedPaymentBasepoint(LDKDelayedPaymentBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentBasepoint)); }
+ operator LDKDelayedPaymentBasepoint() && { LDKDelayedPaymentBasepoint res = self; memset(&self, 0, sizeof(LDKDelayedPaymentBasepoint)); return res; }
+ ~DelayedPaymentBasepoint() { DelayedPaymentBasepoint_free(self); }
+ DelayedPaymentBasepoint& operator=(DelayedPaymentBasepoint&& o) { DelayedPaymentBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentBasepoint)); return *this; }
+ LDKDelayedPaymentBasepoint* operator &() { return &self; }
+ LDKDelayedPaymentBasepoint* operator ->() { return &self; }
+ const LDKDelayedPaymentBasepoint* operator &() const { return &self; }
+ const LDKDelayedPaymentBasepoint* operator ->() const { return &self; }
+};
+class DelayedPaymentKey {
+private:
+ LDKDelayedPaymentKey self;
+public:
+ DelayedPaymentKey(const DelayedPaymentKey&) = delete;
+ DelayedPaymentKey(DelayedPaymentKey&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentKey)); }
+ DelayedPaymentKey(LDKDelayedPaymentKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentKey)); }
+ operator LDKDelayedPaymentKey() && { LDKDelayedPaymentKey res = self; memset(&self, 0, sizeof(LDKDelayedPaymentKey)); return res; }
+ ~DelayedPaymentKey() { DelayedPaymentKey_free(self); }
+ DelayedPaymentKey& operator=(DelayedPaymentKey&& o) { DelayedPaymentKey_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentKey)); return *this; }
+ LDKDelayedPaymentKey* operator &() { return &self; }
+ LDKDelayedPaymentKey* operator ->() { return &self; }
+ const LDKDelayedPaymentKey* operator &() const { return &self; }
+ const LDKDelayedPaymentKey* operator ->() const { return &self; }
+};
+class HtlcBasepoint {
+private:
+ LDKHtlcBasepoint self;
+public:
+ HtlcBasepoint(const HtlcBasepoint&) = delete;
+ HtlcBasepoint(HtlcBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcBasepoint)); }
+ HtlcBasepoint(LDKHtlcBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcBasepoint)); }
+ operator LDKHtlcBasepoint() && { LDKHtlcBasepoint res = self; memset(&self, 0, sizeof(LDKHtlcBasepoint)); return res; }
+ ~HtlcBasepoint() { HtlcBasepoint_free(self); }
+ HtlcBasepoint& operator=(HtlcBasepoint&& o) { HtlcBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(HtlcBasepoint)); return *this; }
+ LDKHtlcBasepoint* operator &() { return &self; }
+ LDKHtlcBasepoint* operator ->() { return &self; }
+ const LDKHtlcBasepoint* operator &() const { return &self; }
+ const LDKHtlcBasepoint* operator ->() const { return &self; }
+};
+class HtlcKey {
+private:
+ LDKHtlcKey self;
+public:
+ HtlcKey(const HtlcKey&) = delete;
+ HtlcKey(HtlcKey&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcKey)); }
+ HtlcKey(LDKHtlcKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcKey)); }
+ operator LDKHtlcKey() && { LDKHtlcKey res = self; memset(&self, 0, sizeof(LDKHtlcKey)); return res; }
+ ~HtlcKey() { HtlcKey_free(self); }
+ HtlcKey& operator=(HtlcKey&& o) { HtlcKey_free(self); self = o.self; memset(&o, 0, sizeof(HtlcKey)); return *this; }
+ LDKHtlcKey* operator &() { return &self; }
+ LDKHtlcKey* operator ->() { return &self; }
+ const LDKHtlcKey* operator &() const { return &self; }
+ const LDKHtlcKey* operator ->() const { return &self; }
+};
+class RevocationBasepoint {
+private:
+ LDKRevocationBasepoint self;
+public:
+ RevocationBasepoint(const RevocationBasepoint&) = delete;
+ RevocationBasepoint(RevocationBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationBasepoint)); }
+ RevocationBasepoint(LDKRevocationBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationBasepoint)); }
+ operator LDKRevocationBasepoint() && { LDKRevocationBasepoint res = self; memset(&self, 0, sizeof(LDKRevocationBasepoint)); return res; }
+ ~RevocationBasepoint() { RevocationBasepoint_free(self); }
+ RevocationBasepoint& operator=(RevocationBasepoint&& o) { RevocationBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(RevocationBasepoint)); return *this; }
+ LDKRevocationBasepoint* operator &() { return &self; }
+ LDKRevocationBasepoint* operator ->() { return &self; }
+ const LDKRevocationBasepoint* operator &() const { return &self; }
+ const LDKRevocationBasepoint* operator ->() const { return &self; }
+};
+class RevocationKey {
+private:
+ LDKRevocationKey self;
+public:
+ RevocationKey(const RevocationKey&) = delete;
+ RevocationKey(RevocationKey&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationKey)); }
+ RevocationKey(LDKRevocationKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationKey)); }
+ operator LDKRevocationKey() && { LDKRevocationKey res = self; memset(&self, 0, sizeof(LDKRevocationKey)); return res; }
+ ~RevocationKey() { RevocationKey_free(self); }
+ RevocationKey& operator=(RevocationKey&& o) { RevocationKey_free(self); self = o.self; memset(&o, 0, sizeof(RevocationKey)); return *this; }
+ LDKRevocationKey* operator &() { return &self; }
+ LDKRevocationKey* operator ->() { return &self; }
+ const LDKRevocationKey* operator &() const { return &self; }
+ const LDKRevocationKey* operator ->() const { return &self; }
+};
+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 in response to a [`chain::Watch::watch_channel`] call. This is
+ * called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
+ *
+ * The data can be stored any way you want, but the identifier provided by LDK 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.
+ *
+ * The [`ChannelMonitor::get_latest_update_id`] uniquely links this call to [`ChainMonitor::channel_monitor_updated`].
+ * For [`Persist::persist_new_channel`], it is only necessary to call [`ChainMonitor::channel_monitor_updated`]
+ * when you return [`ChannelMonitorUpdateStatus::InProgress`].
+ *
+ * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
+ * and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
+ *
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ * [`Writeable::write`]: crate::util::ser::Writeable::write
+ */
+ inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR monitor);
+ /**
+ * 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.
+ *
+ * During blockchain synchronization operations, and in some rare cases, this may be called with
+ * no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
+ * Note that after the full [`ChannelMonitor`] is persisted any previous
+ * [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
+ * applied to the persisted [`ChannelMonitor`] as they were already applied.
+ *
+ * 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. If there are any gaps in the persisted [`ChannelMonitorUpdate`]s,
+ * implementer can safely ignore [`ChannelMonitorUpdate`]s after the gap and load without them.
+ * 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)`.
+ *
+ * The [`ChannelMonitorUpdate::update_id`] or [`ChannelMonitor::get_latest_update_id`] uniquely
+ * links this call to [`ChainMonitor::channel_monitor_updated`].
+ * For [`Persist::update_persisted_channel`], it is only necessary to call [`ChainMonitor::channel_monitor_updated`]
+ * when a [`ChannelMonitorUpdate`] is provided and when you return [`ChannelMonitorUpdateStatus::InProgress`].
+ *
+ * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
+ * [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
+ * [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
+ *
+ * [`Writeable::write`]: crate::util::ser::Writeable::write
+ *
+ * Note that monitor_update (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate monitor_update, const struct LDKChannelMonitor *NONNULL_PTR monitor);
+ /**
+ * Prevents the channel monitor from being loaded on startup.
+ *
+ * Archiving the data in a backup location (rather than deleting it fully) is useful for
+ * hedging against data loss in case of unexpected failure.
+ */
+ inline void archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint);
+};
+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;
+public:
+ ChainMonitor(const ChainMonitor&) = delete;
+ ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
+ ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
+ operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
+ ~ChainMonitor() { ChainMonitor_free(self); }
+ ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
+ LDKChainMonitor* operator &() { return &self; }
+ LDKChainMonitor* operator ->() { return &self; }
+ const LDKChainMonitor* operator &() const { return &self; }
+ const LDKChainMonitor* operator ->() const { return &self; }
+};
+class BlindedMessagePath {
+private:
+ LDKBlindedMessagePath self;
+public:
+ BlindedMessagePath(const BlindedMessagePath&) = delete;
+ BlindedMessagePath(BlindedMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedMessagePath)); }
+ BlindedMessagePath(LDKBlindedMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedMessagePath)); }
+ operator LDKBlindedMessagePath() && { LDKBlindedMessagePath res = self; memset(&self, 0, sizeof(LDKBlindedMessagePath)); return res; }
+ ~BlindedMessagePath() { BlindedMessagePath_free(self); }
+ BlindedMessagePath& operator=(BlindedMessagePath&& o) { BlindedMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedMessagePath)); return *this; }
+ LDKBlindedMessagePath* operator &() { return &self; }
+ LDKBlindedMessagePath* operator ->() { return &self; }
+ const LDKBlindedMessagePath* operator &() const { return &self; }
+ const LDKBlindedMessagePath* operator ->() const { return &self; }
+};
+class NextMessageHop {
+private:
+ LDKNextMessageHop self;
+public:
+ NextMessageHop(const NextMessageHop&) = delete;
+ NextMessageHop(NextMessageHop&& o) : self(o.self) { memset(&o, 0, sizeof(NextMessageHop)); }
+ NextMessageHop(LDKNextMessageHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNextMessageHop)); }
+ operator LDKNextMessageHop() && { LDKNextMessageHop res = self; memset(&self, 0, sizeof(LDKNextMessageHop)); return res; }
+ ~NextMessageHop() { NextMessageHop_free(self); }
+ NextMessageHop& operator=(NextMessageHop&& o) { NextMessageHop_free(self); self = o.self; memset(&o, 0, sizeof(NextMessageHop)); return *this; }
+ LDKNextMessageHop* operator &() { return &self; }
+ LDKNextMessageHop* operator ->() { return &self; }
+ const LDKNextMessageHop* operator &() const { return &self; }
+ const LDKNextMessageHop* operator ->() const { return &self; }
+};
+class MessageForwardNode {
+private:
+ LDKMessageForwardNode self;
+public:
+ MessageForwardNode(const MessageForwardNode&) = delete;
+ MessageForwardNode(MessageForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(MessageForwardNode)); }
+ MessageForwardNode(LDKMessageForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageForwardNode)); }
+ operator LDKMessageForwardNode() && { LDKMessageForwardNode res = self; memset(&self, 0, sizeof(LDKMessageForwardNode)); return res; }
+ ~MessageForwardNode() { MessageForwardNode_free(self); }
+ MessageForwardNode& operator=(MessageForwardNode&& o) { MessageForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(MessageForwardNode)); return *this; }
+ LDKMessageForwardNode* operator &() { return &self; }
+ LDKMessageForwardNode* operator ->() { return &self; }
+ const LDKMessageForwardNode* operator &() const { return &self; }
+ const LDKMessageForwardNode* operator ->() const { return &self; }
+};
+class MessageContext {
+private:
+ LDKMessageContext self;
+public:
+ MessageContext(const MessageContext&) = delete;
+ MessageContext(MessageContext&& o) : self(o.self) { memset(&o, 0, sizeof(MessageContext)); }
+ MessageContext(LDKMessageContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageContext)); }
+ operator LDKMessageContext() && { LDKMessageContext res = self; memset(&self, 0, sizeof(LDKMessageContext)); return res; }
+ ~MessageContext() { MessageContext_free(self); }
+ MessageContext& operator=(MessageContext&& o) { MessageContext_free(self); self = o.self; memset(&o, 0, sizeof(MessageContext)); return *this; }
+ LDKMessageContext* operator &() { return &self; }
+ LDKMessageContext* operator ->() { return &self; }
+ const LDKMessageContext* operator &() const { return &self; }
+ const LDKMessageContext* operator ->() const { return &self; }
+};
+class OffersContext {
+private:
+ LDKOffersContext self;
+public:
+ OffersContext(const OffersContext&) = delete;
+ OffersContext(OffersContext&& o) : self(o.self) { memset(&o, 0, sizeof(OffersContext)); }
+ OffersContext(LDKOffersContext&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersContext)); }
+ operator LDKOffersContext() && { LDKOffersContext res = self; memset(&self, 0, sizeof(LDKOffersContext)); return res; }
+ ~OffersContext() { OffersContext_free(self); }
+ OffersContext& operator=(OffersContext&& o) { OffersContext_free(self); self = o.self; memset(&o, 0, sizeof(OffersContext)); return *this; }
+ LDKOffersContext* operator &() { return &self; }
+ LDKOffersContext* operator ->() { return &self; }
+ const LDKOffersContext* operator &() const { return &self; }
+ const LDKOffersContext* operator ->() const { return &self; }
+};
+class CResult_HtlcKeyDecodeErrorZ {
+private:
+ LDKCResult_HtlcKeyDecodeErrorZ self;
+public:
+ CResult_HtlcKeyDecodeErrorZ(const CResult_HtlcKeyDecodeErrorZ&) = delete;
+ CResult_HtlcKeyDecodeErrorZ(CResult_HtlcKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); }
+ CResult_HtlcKeyDecodeErrorZ(LDKCResult_HtlcKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); }
+ operator LDKCResult_HtlcKeyDecodeErrorZ() && { LDKCResult_HtlcKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); return res; }
+ ~CResult_HtlcKeyDecodeErrorZ() { CResult_HtlcKeyDecodeErrorZ_free(self); }
+ CResult_HtlcKeyDecodeErrorZ& operator=(CResult_HtlcKeyDecodeErrorZ&& o) { CResult_HtlcKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); return *this; }
+ LDKCResult_HtlcKeyDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HtlcKeyDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HtlcKeyDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HtlcKeyDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_TransactionU16LenLimitedNoneZ {
+private:
+ LDKCResult_TransactionU16LenLimitedNoneZ self;
+public:
+ CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
+ CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
+ CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
+ operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
+ ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
+ CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
+ LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
+ LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
+ const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
+ const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
+};
+class CVec_TrackedSpendableOutputZ {
+private:
+ LDKCVec_TrackedSpendableOutputZ self;
+public:
+ CVec_TrackedSpendableOutputZ(const CVec_TrackedSpendableOutputZ&) = delete;
+ CVec_TrackedSpendableOutputZ(CVec_TrackedSpendableOutputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TrackedSpendableOutputZ)); }
+ CVec_TrackedSpendableOutputZ(LDKCVec_TrackedSpendableOutputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TrackedSpendableOutputZ)); }
+ operator LDKCVec_TrackedSpendableOutputZ() && { LDKCVec_TrackedSpendableOutputZ res = self; memset(&self, 0, sizeof(LDKCVec_TrackedSpendableOutputZ)); return res; }
+ ~CVec_TrackedSpendableOutputZ() { CVec_TrackedSpendableOutputZ_free(self); }
+ CVec_TrackedSpendableOutputZ& operator=(CVec_TrackedSpendableOutputZ&& o) { CVec_TrackedSpendableOutputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TrackedSpendableOutputZ)); return *this; }
+ LDKCVec_TrackedSpendableOutputZ* operator &() { return &self; }
+ LDKCVec_TrackedSpendableOutputZ* operator ->() { return &self; }
+ const LDKCVec_TrackedSpendableOutputZ* operator &() const { return &self; }
+ const LDKCVec_TrackedSpendableOutputZ* 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_PhantomRouteHintsDecodeErrorZ {
+private:
+ LDKCResult_PhantomRouteHintsDecodeErrorZ self;
+public:
+ CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
+ CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
+ CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
+ operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
+ ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
+ CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
+ LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_FundingCreatedDecodeErrorZ {
+private:
+ LDKCResult_FundingCreatedDecodeErrorZ self;
+public:
+ CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
+ CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
+ CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
+ operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
+ ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
+ CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
+ LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_u32TxOutZZ {
+private:
+ LDKCVec_C2Tuple_u32TxOutZZ self;
+public:
+ CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
+ CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
+ CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
+ operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
+ ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
+ CVec_C2Tuple_u32TxOutZZ& operator=(CVec_C2Tuple_u32TxOutZZ&& o) { CVec_C2Tuple_u32TxOutZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); return *this; }
+ LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
+};
+class CResult_RetryDecodeErrorZ {
+private:
+ LDKCResult_RetryDecodeErrorZ self;
+public:
+ CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
+ CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
+ CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
+ operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
+ ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
+ CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
+ LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_BlindedForwardDecodeErrorZ {
+private:
+ LDKCResult_BlindedForwardDecodeErrorZ self;
+public:
+ CResult_BlindedForwardDecodeErrorZ(const CResult_BlindedForwardDecodeErrorZ&) = delete;
+ CResult_BlindedForwardDecodeErrorZ(CResult_BlindedForwardDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); }
+ CResult_BlindedForwardDecodeErrorZ(LDKCResult_BlindedForwardDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); }
+ operator LDKCResult_BlindedForwardDecodeErrorZ() && { LDKCResult_BlindedForwardDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); return res; }
+ ~CResult_BlindedForwardDecodeErrorZ() { CResult_BlindedForwardDecodeErrorZ_free(self); }
+ CResult_BlindedForwardDecodeErrorZ& operator=(CResult_BlindedForwardDecodeErrorZ&& o) { CResult_BlindedForwardDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedForwardDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedForwardDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedForwardDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedForwardDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelInfoDecodeErrorZ {
+private:
+ LDKCResult_ChannelInfoDecodeErrorZ self;
+public:
+ CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
+ CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
+ CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
+ operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
+ ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
+ CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_PaymentContextZ {
+private:
+ LDKCOption_PaymentContextZ self;
+public:
+ COption_PaymentContextZ(const COption_PaymentContextZ&) = delete;
+ COption_PaymentContextZ(COption_PaymentContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentContextZ)); }
+ COption_PaymentContextZ(LDKCOption_PaymentContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentContextZ)); }
+ operator LDKCOption_PaymentContextZ() && { LDKCOption_PaymentContextZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentContextZ)); return res; }
+ ~COption_PaymentContextZ() { COption_PaymentContextZ_free(self); }
+ COption_PaymentContextZ& operator=(COption_PaymentContextZ&& o) { COption_PaymentContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentContextZ)); return *this; }
+ LDKCOption_PaymentContextZ* operator &() { return &self; }
+ LDKCOption_PaymentContextZ* operator ->() { return &self; }
+ const LDKCOption_PaymentContextZ* operator &() const { return &self; }
+ const LDKCOption_PaymentContextZ* operator ->() const { return &self; }
+};
+class COption_MaxDustHTLCExposureZ {
+private:
+ LDKCOption_MaxDustHTLCExposureZ self;
+public:
+ COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
+ COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
+ COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
+ operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
+ ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
+ COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
+ LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
+ LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
+ const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
+ const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
+};
+class CResult_NoneSendErrorZ {
+private:
+ LDKCResult_NoneSendErrorZ self;
+public:
+ CResult_NoneSendErrorZ(const CResult_NoneSendErrorZ&) = delete;
+ CResult_NoneSendErrorZ(CResult_NoneSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); }
+ CResult_NoneSendErrorZ(LDKCResult_NoneSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSendErrorZ)); }
+ operator LDKCResult_NoneSendErrorZ() && { LDKCResult_NoneSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSendErrorZ)); return res; }
+ ~CResult_NoneSendErrorZ() { CResult_NoneSendErrorZ_free(self); }
+ CResult_NoneSendErrorZ& operator=(CResult_NoneSendErrorZ&& o) { CResult_NoneSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); return *this; }
+ LDKCResult_NoneSendErrorZ* operator &() { return &self; }
+ LDKCResult_NoneSendErrorZ* operator ->() { return &self; }
+ const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
+ const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_u8ZPeerHandleErrorZ {
+private:
+ LDKCResult_CVec_u8ZPeerHandleErrorZ self;
+public:
+ CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
+ CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
+ CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
+ operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
+ ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
+ CResult_CVec_u8ZPeerHandleErrorZ& operator=(CResult_CVec_u8ZPeerHandleErrorZ&& o) { CResult_CVec_u8ZPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); return *this; }
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
+ LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
+ const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
+ const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
+};
+class CResult_OnionPacketDecodeErrorZ {
+private:
+ LDKCResult_OnionPacketDecodeErrorZ self;
+public:
+ CResult_OnionPacketDecodeErrorZ(const CResult_OnionPacketDecodeErrorZ&) = delete;
+ CResult_OnionPacketDecodeErrorZ(CResult_OnionPacketDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); }
+ CResult_OnionPacketDecodeErrorZ(LDKCResult_OnionPacketDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); }
+ operator LDKCResult_OnionPacketDecodeErrorZ() && { LDKCResult_OnionPacketDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); return res; }
+ ~CResult_OnionPacketDecodeErrorZ() { CResult_OnionPacketDecodeErrorZ_free(self); }
+ CResult_OnionPacketDecodeErrorZ& operator=(CResult_OnionPacketDecodeErrorZ&& o) { CResult_OnionPacketDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); return *this; }
+ LDKCResult_OnionPacketDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OnionPacketDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OnionPacketDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OnionPacketDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_NetworkUpdateZ {
+private:
+ LDKCOption_NetworkUpdateZ self;
+public:
+ 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:
+ LDKCOption_u64Z self;
+public:
+ COption_u64Z(const COption_u64Z&) = delete;
+ COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
+ COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
+ operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
+ ~COption_u64Z() { COption_u64Z_free(self); }
+ COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
+ LDKCOption_u64Z* operator &() { return &self; }
+ LDKCOption_u64Z* operator ->() { return &self; }
+ const LDKCOption_u64Z* operator &() const { return &self; }
+ const LDKCOption_u64Z* 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 C2Tuple_OnionMessageContentsResponseInstructionZ {
+private:
+ LDKC2Tuple_OnionMessageContentsResponseInstructionZ self;
+public:
+ C2Tuple_OnionMessageContentsResponseInstructionZ(const C2Tuple_OnionMessageContentsResponseInstructionZ&) = delete;
+ C2Tuple_OnionMessageContentsResponseInstructionZ(C2Tuple_OnionMessageContentsResponseInstructionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsResponseInstructionZ)); }
+ C2Tuple_OnionMessageContentsResponseInstructionZ(LDKC2Tuple_OnionMessageContentsResponseInstructionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OnionMessageContentsResponseInstructionZ)); }
+ operator LDKC2Tuple_OnionMessageContentsResponseInstructionZ() && { LDKC2Tuple_OnionMessageContentsResponseInstructionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OnionMessageContentsResponseInstructionZ)); return res; }
+ ~C2Tuple_OnionMessageContentsResponseInstructionZ() { C2Tuple_OnionMessageContentsResponseInstructionZ_free(self); }
+ C2Tuple_OnionMessageContentsResponseInstructionZ& operator=(C2Tuple_OnionMessageContentsResponseInstructionZ&& o) { C2Tuple_OnionMessageContentsResponseInstructionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsResponseInstructionZ)); return *this; }
+ LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator &() { return &self; }
+ LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator ->() { return &self; }
+ const LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator &() const { return &self; }
+ const LDKC2Tuple_OnionMessageContentsResponseInstructionZ* operator ->() const { return &self; }
+};
+class CResult_RouteHintDecodeErrorZ {
+private:
+ LDKCResult_RouteHintDecodeErrorZ self;
+public:
+ CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
+ CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
+ CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
+ operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
+ ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
+ CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
+ LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RouteHintDecodeErrorZ* 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 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
+private:
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
+public:
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
+ operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
+ ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ& operator=(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return *this; }
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
+};
+class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+private:
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
+public:
+ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
+ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
+ operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
+ ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
+ COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ& operator=(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return *this; }
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
+ const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
+ const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
+};
+class CResult_COption_APIErrorZDecodeErrorZ {
+private:
+ LDKCResult_COption_APIErrorZDecodeErrorZ self;
+public:
+ CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
+ CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
+ CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
+ operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
+ ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
+ CResult_COption_APIErrorZDecodeErrorZ& operator=(CResult_COption_APIErrorZDecodeErrorZ&& o) { CResult_COption_APIErrorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_UpdateAddHTLCZ {
+private:
+ LDKCVec_UpdateAddHTLCZ self;
+public:
+ CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
+ CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
+ CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
+ operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
+ ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
+ CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
+ LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
+ LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
+ const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
+ const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }