namespace LDK {
// Forward declarations
class Str;
-class BlindedRoute;
-class BlindedHop;
-class CounterpartyCommitmentSecrets;
-class TxCreationKeys;
-class ChannelPublicKeys;
-class HTLCOutputInCommitment;
-class ChannelTransactionParameters;
-class CounterpartyChannelTransactionParameters;
-class DirectedChannelTransactionParameters;
-class HolderCommitmentTransaction;
-class BuiltCommitmentTransaction;
-class ClosingTransaction;
-class TrustedClosingTransaction;
-class CommitmentTransaction;
-class TrustedCommitmentTransaction;
-class ShutdownScript;
-class InvalidShutdownScript;
+class RefundMaybeWithDerivedMetadataBuilder;
+class Refund;
+class Retry;
+class RetryableSendFailure;
+class PaymentSendFailure;
+class Bolt12PaymentError;
+class ProbeSendFailure;
+class RecipientOnionFields;
+class InvoiceWithExplicitSigningPubkeyBuilder;
+class InvoiceWithDerivedSigningPubkeyBuilder;
+class UnsignedBolt12Invoice;
+class SignBolt12InvoiceFn;
+class Bolt12Invoice;
+class DelayedPaymentOutputDescriptor;
+class StaticPaymentOutputDescriptor;
+class SpendableOutputDescriptor;
+class ChannelDerivationParameters;
+class HTLCDescriptor;
+class ChannelSigner;
+class Recipient;
+class EntropySource;
+class NodeSigner;
+class OutputSpender;
+class SignerProvider;
+class ChangeDestinationSource;
+class InMemorySigner;
+class KeysManager;
+class PhantomKeysManager;
+class RandomBytes;
class BackgroundProcessor;
class GossipSync;
+class DefaultRouter;
+class Router;
+class ScorerAccountingForInFlightHtlcs;
+class InFlightHtlcs;
class RouteHop;
+class BlindedTail;
+class Path;
class Route;
class RouteParameters;
class PaymentParameters;
-class RouteHint;
-class RouteHintHop;
-class BroadcasterInterface;
-class ConfirmationTarget;
-class FeeEstimator;
-class PaymentPurpose;
-class ClosureReason;
-class HTLCDestination;
-class Event;
-class MessageSendEvent;
-class MessageSendEventsProvider;
-class OnionMessageProvider;
-class EventsProvider;
-class EventHandler;
-class BestBlock;
-class AccessError;
-class Access;
-class Listen;
-class Confirm;
-class ChannelMonitorUpdateErr;
-class Watch;
-class Filter;
-class WatchedOutput;
+class Payee;
+class FirstHopCandidate;
+class PublicHopCandidate;
+class PrivateHopCandidate;
+class BlindedPathCandidate;
+class OneHopBlindedPathCandidate;
+class CandidateRouteHop;
+class UntrustedString;
+class PrintableString;
+class ScoreLookUp;
+class ScoreUpdate;
class Score;
class LockableScore;
class WriteableScore;
class MultiThreadedLockableScore;
-class MultiThreadedScoreLock;
+class MultiThreadedScoreLockRead;
+class MultiThreadedScoreLockWrite;
class ChannelUsage;
class FixedPenaltyScorer;
class ProbabilisticScorer;
-class ProbabilisticScoringParameters;
-class InitFeatures;
-class NodeFeatures;
-class ChannelFeatures;
-class InvoiceFeatures;
-class ChannelTypeFeatures;
+class ProbabilisticScoringFeeParameters;
+class ProbabilisticScoringDecayParameters;
+class BestBlock;
+class Listen;
+class Confirm;
+class ChannelMonitorUpdateStatus;
+class Watch;
+class Filter;
+class WatchedOutput;
+class OfferId;
+class OfferWithExplicitMetadataBuilder;
+class OfferWithDerivedMetadataBuilder;
+class Offer;
+class Amount;
+class Quantity;
class NodeId;
class NetworkGraph;
class ReadOnlyNetworkGraph;
class ChannelInfo;
class DirectedChannelInfo;
class EffectiveCapacity;
-class RoutingFees;
+class NodeAnnouncementDetails;
class NodeAnnouncementInfo;
class NodeAlias;
class NodeInfo;
-class DelayedPaymentOutputDescriptor;
-class StaticPaymentOutputDescriptor;
-class SpendableOutputDescriptor;
-class BaseSign;
-class Sign;
-class Recipient;
-class KeysInterface;
-class InMemorySigner;
-class KeysManager;
-class PhantomKeysManager;
-class FilesystemPersister;
+class ShortChannelIdError;
+class InboundHTLCErr;
+class AnchorDescriptor;
+class BumpTransactionEvent;
+class Input;
+class Utxo;
+class CoinSelection;
+class CoinSelectionSource;
+class WalletSource;
+class Wallet;
+class BumpTransactionEventHandler;
+class PendingHTLCRouting;
+class BlindedForward;
+class PendingHTLCInfo;
+class BlindedFailure;
+class FailureCode;
class ChannelManager;
class ChainParameters;
-class CounterpartyForwardingInfo;
-class ChannelCounterparty;
-class ChannelDetails;
-class PaymentSendFailure;
+class RecentPaymentDetails;
class PhantomRouteHints;
class ChannelManagerReadArgs;
class ChannelHandshakeConfig;
class ChannelHandshakeLimits;
+class MaxDustHTLCExposure;
class ChannelConfig;
+class ChannelConfigUpdate;
class UserConfig;
class APIError;
-class BigSize;
-class Hostname;
-class OutPoint;
-class CustomMessageReader;
-class Type;
-class InvoicePayer;
-class Payer;
-class Router;
-class Retry;
-class PaymentError;
-class InFlightHtlcs;
-class ParseError;
-class ParseOrSemanticError;
-class Invoice;
-class SignedRawInvoice;
-class RawInvoice;
-class RawDataPart;
-class PositiveTimestamp;
-class SiPrefix;
-class Currency;
-class Sha256;
-class Description;
-class PayeePubKey;
-class ExpiryTime;
-class MinFinalCltvExpiry;
-class Fallback;
-class InvoiceSignature;
-class PrivateRoute;
-class CreationError;
-class SemanticError;
-class SignOrCreationError;
+class TaggedHash;
+class SignError;
+class EcdsaChannelSigner;
class ChannelMonitorUpdate;
class MonitorEvent;
class HTLCUpdate;
+class BalanceSource;
class Balance;
class ChannelMonitor;
class ExpandedKey;
class ErroringMessageHandler;
class MessageHandler;
class SocketDescriptor;
+class PeerDetails;
class PeerHandleError;
class PeerManager;
-class OnionMessenger;
-class Destination;
-class SendError;
+class GraphSyncError;
class RapidGossipSync;
+class KVStore;
class Persister;
+class MonitorUpdatingPersister;
+class InvoiceRequestWithExplicitPayerIdBuilder;
+class InvoiceRequestWithDerivedPayerIdBuilder;
+class UnsignedInvoiceRequest;
+class SignInvoiceRequestFn;
+class InvoiceRequest;
+class VerifiedInvoiceRequest;
+class InvoiceRequestFields;
class DecodeError;
class Init;
class ErrorMessage;
class WarningMessage;
class Ping;
class Pong;
+class CommonOpenChannelFields;
+class ChannelParameters;
class OpenChannel;
+class OpenChannelV2;
+class CommonAcceptChannelFields;
class AcceptChannel;
+class AcceptChannelV2;
class FundingCreated;
class FundingSigned;
class ChannelReady;
+class Stfu;
+class SpliceInit;
+class SpliceAck;
+class SpliceLocked;
+class TxAddInput;
+class TxAddOutput;
+class TxRemoveInput;
+class TxRemoveOutput;
+class TxComplete;
+class TxSignatures;
+class TxInitRbf;
+class TxAckRbf;
+class TxAbort;
class Shutdown;
class ClosingSignedFeeRange;
class ClosingSigned;
class UpdateFulfillHTLC;
class UpdateFailHTLC;
class UpdateFailMalformedHTLC;
+class CommitmentSignedBatch;
class CommitmentSigned;
class RevokeAndACK;
class UpdateFee;
-class DataLossProtect;
class ChannelReestablish;
class AnnouncementSignatures;
-class NetAddress;
+class SocketAddress;
+class SocketAddressParseError;
+class UnsignedGossipMessage;
class UnsignedNodeAnnouncement;
class NodeAnnouncement;
class UnsignedChannelAnnouncement;
class ChannelMessageHandler;
class RoutingMessageHandler;
class OnionMessageHandler;
-class GraphSyncError;
-class DefaultRouter;
+class FinalOnionHopData;
+class OnionPacket;
+class TrampolineOnionPacket;
class Level;
class Record;
class Logger;
+class InboundHTLCStateDetails;
+class InboundHTLCDetails;
+class OutboundHTLCStateDetails;
+class OutboundHTLCDetails;
+class CounterpartyForwardingInfo;
+class ChannelCounterparty;
+class ChannelDetails;
+class ChannelShutdownState;
class FutureCallback;
class Future;
-class MonitorUpdateId;
+class Sleeper;
+class AsyncPaymentsMessageHandler;
+class AsyncPaymentsMessage;
+class HeldHtlcAvailable;
+class ReleaseHeldHtlc;
+class OffersMessageHandler;
+class OffersMessage;
+class HTLCClaim;
+class CounterpartyCommitmentSecrets;
+class TxCreationKeys;
+class ChannelPublicKeys;
+class HTLCOutputInCommitment;
+class ChannelTransactionParameters;
+class CounterpartyChannelTransactionParameters;
+class DirectedChannelTransactionParameters;
+class HolderCommitmentTransaction;
+class BuiltCommitmentTransaction;
+class ClosingTransaction;
+class TrustedClosingTransaction;
+class CommitmentTransaction;
+class TrustedCommitmentTransaction;
+class ShutdownScript;
+class InvalidShutdownScript;
+class Bolt12ParseError;
+class Bolt12SemanticError;
+class BroadcasterInterface;
+class ConfirmationTarget;
+class FeeEstimator;
+class Packet;
+class ParsedOnionMessageContents;
+class OnionMessageContents;
+class FundingInfo;
+class PaymentPurpose;
+class ClaimedHTLC;
+class PathFailure;
+class ClosureReason;
+class HTLCDestination;
+class PaymentFailureReason;
+class Event;
+class MessageSendEvent;
+class MessageSendEventsProvider;
+class EventsProvider;
+class ReplayEvent;
+class EventHandler;
+class Nonce;
+class RoutingFees;
+class RouteHint;
+class RouteHintHop;
+class Bolt11ParseError;
+class ParseOrSemanticError;
+class Bolt11Invoice;
+class SignedRawBolt11Invoice;
+class RawBolt11Invoice;
+class RawDataPart;
+class PositiveTimestamp;
+class SiPrefix;
+class Currency;
+class Sha256;
+class Description;
+class PayeePubKey;
+class ExpiryTime;
+class MinFinalCltvExpiryDelta;
+class Fallback;
+class Bolt11InvoiceSignature;
+class PrivateRoute;
+class CreationError;
+class Bolt11SemanticError;
+class SignOrCreationError;
+class OutPoint;
+class BigSize;
+class Hostname;
+class TransactionU16LenLimited;
+class ChannelId;
+class CustomMessageReader;
+class Type;
+class BlindedPayInfo;
+class BlindedPaymentPath;
+class PaymentForwardNode;
+class ForwardTlvs;
+class ReceiveTlvs;
+class PaymentRelay;
+class PaymentConstraints;
+class PaymentContext;
+class UnknownPaymentContext;
+class Bolt12OfferContext;
+class Bolt12RefundContext;
+class UtxoLookupError;
+class UtxoResult;
+class UtxoLookup;
+class UtxoFuture;
+class OnionMessenger;
+class Responder;
+class ResponseInstruction;
+class MessageSendInstructions;
+class MessageRouter;
+class DefaultMessageRouter;
+class OnionMessagePath;
+class Destination;
+class SendSuccess;
+class SendError;
+class CustomOnionMessageHandler;
+class PeeledOnion;
+class FilesystemStore;
+class InitFeatures;
+class NodeFeatures;
+class ChannelFeatures;
+class Bolt11InvoiceFeatures;
+class OfferFeatures;
+class InvoiceRequestFeatures;
+class Bolt12InvoiceFeatures;
+class BlindedHopFeatures;
+class ChannelTypeFeatures;
+class IntroductionNode;
+class Direction;
+class NodeIdLookUp;
+class EmptyNodeIdLookUp;
+class BlindedHop;
+class InvoiceError;
+class ErroneousField;
+class TrackedSpendableOutput;
+class OutputSpendStatus;
+class OutputSweeper;
+class SpendingDelay;
+class DelayedPaymentBasepoint;
+class DelayedPaymentKey;
+class HtlcBasepoint;
+class HtlcKey;
+class RevocationBasepoint;
+class RevocationKey;
class Persist;
class LockedChannelMonitor;
class ChainMonitor;
-class CVec_SpendableOutputDescriptorZ;
+class BlindedMessagePath;
+class NextMessageHop;
+class MessageForwardNode;
+class MessageContext;
+class OffersContext;
+class CResult_HtlcKeyDecodeErrorZ;
+class CResult_TransactionU16LenLimitedNoneZ;
+class CVec_TrackedSpendableOutputZ;
class CResult_LockedChannelMonitorNoneZ;
class CResult_PhantomRouteHintsDecodeErrorZ;
-class COption_C2Tuple_u64u64ZZ;
-class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ;
-class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ;
-class CResult_HTLCUpdateDecodeErrorZ;
-class C2Tuple_SignatureCVec_SignatureZZ;
+class CResult_FundingCreatedDecodeErrorZ;
class CVec_C2Tuple_u32TxOutZZ;
+class CResult_RetryDecodeErrorZ;
+class CResult_BlindedForwardDecodeErrorZ;
class CResult_ChannelInfoDecodeErrorZ;
-class COption_WriteableScoreZ;
+class COption_PaymentContextZ;
+class COption_MaxDustHTLCExposureZ;
class CResult_NoneSendErrorZ;
-class CResult_FundingCreatedDecodeErrorZ;
-class CResult_ChannelAnnouncementDecodeErrorZ;
-class CResult_PositiveTimestampCreationErrorZ;
-class CVec_OutPointZ;
class CResult_CVec_u8ZPeerHandleErrorZ;
-class CResult_InvoiceFeaturesDecodeErrorZ;
+class CResult_OnionPacketDecodeErrorZ;
class COption_NetworkUpdateZ;
class COption_u64Z;
-class CResult_TxOutAccessErrorZ;
-class CResult_TrustedClosingTransactionNoneZ;
-class CResult_PaymentPreimageAPIErrorZ;
-class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class CResult_GossipTimestampFilterDecodeErrorZ;
+class C2Tuple_OnionMessageContentsResponseInstructionZ;
class CResult_RouteHintDecodeErrorZ;
-class C2Tuple_PublicKeyTypeZ;
-class CResult_NetAddressDecodeErrorZ;
+class COption_FilterZ;
+class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
-class CResult_ChannelReestablishDecodeErrorZ;
+class CResult_COption_APIErrorZDecodeErrorZ;
class CVec_UpdateAddHTLCZ;
-class CResult_CommitmentSignedDecodeErrorZ;
-class COption_u32Z;
-class CResult_InitFeaturesDecodeErrorZ;
+class CResult_TxAbortDecodeErrorZ;
class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
-class CResult_PaymentIdPaymentSendFailureZ;
-class CResult_OnionMessageDecodeErrorZ;
-class CResult_CommitmentTransactionDecodeErrorZ;
+class COption_u32Z;
+class CResult_RecipientOnionFieldsNoneZ;
+class C2Tuple__u1632_u1632Z;
+class CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ;
+class C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ;
class CResult_TransactionNoneZ;
+class CResult_CVec_StrZIOErrorZ;
+class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ;
+class COption_ECDSASignatureZ;
class CResult_ClosingSignedFeeRangeDecodeErrorZ;
-class CResult_PingDecodeErrorZ;
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
-class CResult_ReplyChannelRangeDecodeErrorZ;
-class CResult_GossipTimestampFilterDecodeErrorZ;
-class CResult_InvoiceSignOrCreationErrorZ;
-class CVec_TransactionOutputsZ;
-class CResult_ErrorMessageDecodeErrorZ;
+class CResult_CommitmentSignedDecodeErrorZ;
+class CResult_CommitmentTransactionDecodeErrorZ;
+class CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ;
+class CResult_StfuDecodeErrorZ;
class CResult_OpenChannelDecodeErrorZ;
-class CVec_CVec_u8ZZ;
-class COption_FilterZ;
-class CResult_SecretKeyErrorZ;
-class CResult_ShutdownScriptDecodeErrorZ;
-class CResult_ProbabilisticScorerDecodeErrorZ;
+class CResult_ErrorMessageDecodeErrorZ;
+class COption_APIErrorZ;
+class CVec_PeerDetailsZ;
+class CResult_u64ShortChannelIdErrorZ;
class CResult_QueryChannelRangeDecodeErrorZ;
-class CResult_TxCreationKeysDecodeErrorZ;
-class C2Tuple_usizeTransactionZ;
+class CVec_InputZ;
class CResult_ChannelFeaturesDecodeErrorZ;
-class CVec_ChannelMonitorZ;
-class CVec_TransactionZ;
class CResult_ChannelReadyDecodeErrorZ;
-class CResult_RouteHopDecodeErrorZ;
+class CVec_TransactionZ;
class CResult_UpdateFeeDecodeErrorZ;
-class CResult_NodeAnnouncementDecodeErrorZ;
-class CVec_BalanceZ;
-class CResult_HTLCOutputInCommitmentDecodeErrorZ;
-class CResult_boolLightningErrorZ;
-class CResult_TxCreationKeysErrorZ;
-class COption_HTLCDestinationZ;
+class CResult_NoneBolt11SemanticErrorZ;
+class CResult_RevocationBasepointDecodeErrorZ;
+class COption_OnionMessageContentsZ;
+class CResult_NoneRetryableSendFailureZ;
+class CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ;
class CResult_NodeIdDecodeErrorZ;
-class CResult_ShutdownScriptInvalidShutdownScriptZ;
+class CResult_boolLightningErrorZ;
+class CResult_ChannelShutdownStateDecodeErrorZ;
class CResult_NodeAnnouncementInfoDecodeErrorZ;
+class CResult_InvoiceRequestBolt12SemanticErrorZ;
class CResult_COption_NetworkUpdateZDecodeErrorZ;
-class CResult_RecoverableSignatureNoneZ;
-class C2Tuple_BlockHashChannelMonitorZ;
-class C3Tuple_RawInvoice_u832InvoiceSignatureZ;
class CVec_UpdateFailMalformedHTLCZ;
-class CResult_FundingSignedDecodeErrorZ;
-class CResult_NetworkGraphDecodeErrorZ;
+class CResult_ShutdownScriptNoneZ;
+class CResult_PendingHTLCInfoInboundHTLCErrZ;
+class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ;
+class CResult_PendingHTLCInfoDecodeErrorZ;
+class CResult_SpliceInitDecodeErrorZ;
+class CResult_HTLCOutputInCommitmentDecodeErrorZ;
class CVec_RouteHopZ;
-class CResult_NodeInfoDecodeErrorZ;
-class CVec_NodeIdZ;
-class CResult_RouteLightningErrorZ;
-class CResult_ChannelPublicKeysDecodeErrorZ;
-class CVec_u8Z;
-class CVec_C2Tuple_BlockHashChannelMonitorZZ;
-class CResult_NonePaymentSendFailureZ;
+class CResult_ShutdownScriptInvalidShutdownScriptZ;
+class CResult_CVec_UtxoZNoneZ;
+class CResult_CVec_u8ZIOErrorZ;
+class COption_HTLCDestinationZ;
+class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ;
class CVec_ThirtyTwoBytesZ;
+class CResult_ChannelMonitorUpdateStatusNoneZ;
class CResult_ClosingSignedDecodeErrorZ;
class CVec_CResult_NoneAPIErrorZZ;
-class CResult_HolderCommitmentTransactionDecodeErrorZ;
+class CResult_SchnorrSignatureNoneZ;
+class C2Tuple_ReleaseHeldHtlcResponseInstructionZ;
class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
-class CResult_ChannelCounterpartyDecodeErrorZ;
-class CResult_WarningMessageDecodeErrorZ;
-class CResult_SignatureNoneZ;
+class CResult_HTLCDescriptorDecodeErrorZ;
+class CVec_RecentPaymentDetailsZ;
class CVec_RouteHintHopZ;
-class CResult_SecretKeyNoneZ;
-class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ;
-class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ;
+class CResult_UntrustedStringDecodeErrorZ;
+class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ;
class CResult_PaymentParametersDecodeErrorZ;
-class CResult_PaymentPurposeDecodeErrorZ;
-class CResult_InitDecodeErrorZ;
-class CResult_OutPointDecodeErrorZ;
-class CResult_BlindedRouteDecodeErrorZ;
-class CVec_ChannelDetailsZ;
-class CVec_MessageSendEventZ;
-class CResult_SignDecodeErrorZ;
-class COption_NetAddressZ;
-class C2Tuple_OutPointScriptZ;
-class CResult_RouteHintHopDecodeErrorZ;
-class CResult_C2Tuple_SignatureSignatureZNoneZ;
-class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
-class CResult_SharedSecretNoneZ;
-class CVec_TxidZ;
-class COption_AccessZ;
-class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ;
-class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ;
+class CResult_DelayedPaymentBasepointDecodeErrorZ;
+class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
+class COption_U128Z;
+class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
+class CVec_MessageForwardNodeZ;
+class CResult_TxAckRbfDecodeErrorZ;
+class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
+class COption_UtxoLookupZ;
+class CResult__u832NoneZ;
class CResult_PongDecodeErrorZ;
-class CResult_CVec_CVec_u8ZZNoneZ;
-class C2Tuple_SignatureSignatureZ;
-class C2Tuple_PaymentHashPaymentSecretZ;
-class C2Tuple_BlockHashChannelManagerZ;
-class CResult_ChannelTransactionParametersDecodeErrorZ;
-class CResult_AcceptChannelDecodeErrorZ;
-class CVec_SignatureZ;
-class CVec_u64Z;
class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
+class CResult_ChannelIdAPIErrorZ;
+class CResult_CVec_u8ZNoneZ;
+class CVec_C2Tuple_ChannelIdPublicKeyZZ;
+class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
+class CResult_ChannelTransactionParametersDecodeErrorZ;
+class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ;
class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
-class C2Tuple_PaymentHashPaymentIdZ;
-class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ;
-class CResult_NoneErrorZ;
-class CResult_COption_HTLCDestinationZDecodeErrorZ;
class CResult_InFlightHtlcsDecodeErrorZ;
-class CResult_StringErrorZ;
-class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ;
-class COption_EventZ;
-class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ;
-class CResult_ChannelTypeFeaturesDecodeErrorZ;
-class CResult_SiPrefixParseErrorZ;
-class CVec_RouteHintZ;
-class COption_u16Z;
+class CResult_CommitmentSignedBatchDecodeErrorZ;
+class CResult_COption_HTLCDestinationZDecodeErrorZ;
+class CResult_Bolt12OfferContextDecodeErrorZ;
+class CResult_ThirtyTwoBytesNoneZ;
+class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
+class CResult_SendSuccessSendErrorZ;
+class CResult_NoneReplayEventZ;
+class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ;
class CResult_BlindedHopDecodeErrorZ;
-class CVec_CVec_RouteHopZZ;
-class CResult_TrustedCommitmentTransactionNoneZ;
-class CResult_FixedPenaltyScorerDecodeErrorZ;
class CResult_NoneLightningErrorZ;
+class CResult_FixedPenaltyScorerDecodeErrorZ;
class CResult_NonePeerHandleErrorZ;
+class CResult_TrustedCommitmentTransactionNoneZ;
+class CResult_FinalOnionHopDataDecodeErrorZ;
class CResult_COption_EventZDecodeErrorZ;
-class CResult_CVec_SignatureZNoneZ;
-class COption_CVec_NetAddressZZ;
-class CResult__u832APIErrorZ;
-class CResult_PaymentIdPaymentErrorZ;
-class CResult_DescriptionCreationErrorZ;
-class CResult_RoutingFeesDecodeErrorZ;
-class CResult_PayeePubKeyErrorZ;
+class COption_SocketAddressZ;
class CResult_COption_MonitorEventZDecodeErrorZ;
-class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
-class CVec_C2Tuple_PublicKeyTypeZZ;
-class CResult_InvoiceSemanticErrorZ;
-class CResult_u32GraphSyncErrorZ;
-class CResult_UpdateAddHTLCDecodeErrorZ;
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
-class CResult_NoneAPIErrorZ;
-class CVec_NetAddressZ;
-class CResult_ChannelDetailsDecodeErrorZ;
-class CVec_PublicKeyZ;
-class CVec_C2Tuple_usizeTransactionZZ;
+class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
+class CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ;
+class CResult_RoutingFeesDecodeErrorZ;
+class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
+class CResult_DescriptionCreationErrorZ;
+class CResult_PaymentRelayDecodeErrorZ;
class CResult_QueryShortChannelIdsDecodeErrorZ;
-class CVec_PhantomRouteHintsZ;
+class CResult_VerifiedInvoiceRequestNoneZ;
+class CResult_UpdateAddHTLCDecodeErrorZ;
+class COption_OutboundHTLCStateDetailsZ;
class COption_MonitorEventZ;
-class C2Tuple_u64u64Z;
class COption_TypeZ;
class CResult_COption_TypeZDecodeErrorZ;
-class C2Tuple_u32TxOutZ;
+class CResult_OfferDecodeErrorZ;
+class CResult_COption_PathFailureZDecodeErrorZ;
+class CResult_Bolt11InvoiceSignOrCreationErrorZ;
+class CResult_BlindedMessagePathNoneZ;
class CResult_UpdateFailHTLCDecodeErrorZ;
-class CResult_InvoiceParseOrSemanticErrorZ;
-class CResult_PaymentSecretNoneZ;
-class CResult_ChannelConfigDecodeErrorZ;
-class CVec_PrivateRouteZ;
+class CResult_BlindedPaymentPathNoneZ;
+class CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ;
+class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
class CResult_SpendableOutputDescriptorDecodeErrorZ;
class CResult_RevokeAndACKDecodeErrorZ;
class CResult_UnsignedChannelUpdateDecodeErrorZ;
-class CResult_ShutdownDecodeErrorZ;
-class CVec_EventZ;
-class CResult_NoneSemanticErrorZ;
-class CVec_MonitorEventZ;
-class CVec_PaymentPreimageZ;
-class CVec_C2Tuple_u32ScriptZZ;
-class CResult_NoneChannelMonitorUpdateErrZ;
+class CResult_PayeePubKeySecp256k1ErrorZ;
+class C2Tuple__u832u16Z;
+class CResult_BlindedMessagePathDecodeErrorZ;
+class CResult_CVec_BlindedMessagePathZNoneZ;
+class COption_BigEndianScalarZ;
+class CVec_ChannelIdZ;
+class CResult_PublicKeySecp256k1ErrorZ;
+class C2Tuple_OnionMessageContentsMessageSendInstructionsZ;
+class CVec_BlindedHopZ;
+class CResult_ReleaseHeldHtlcDecodeErrorZ;
+class CResult_CVec_ECDSASignatureZNoneZ;
class CResult_COption_ClosureReasonZDecodeErrorZ;
-class CResult_PublicKeyErrorZ;
-class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
-class CResult_NoneNoneZ;
+class CResult_NonceDecodeErrorZ;
class CResult_RouteParametersDecodeErrorZ;
-class COption_ClosureReasonZ;
-class CResult_NodeAliasDecodeErrorZ;
-class CVec_APIErrorZ;
class CResult_PrivateRouteCreationErrorZ;
-class CResult_boolPeerHandleErrorZ;
+class CResult_InvoiceErrorDecodeErrorZ;
+class CResult_NodeAliasDecodeErrorZ;
+class C2Tuple_BestBlockOutputSweeperZ;
+class C2Tuple_OutPointCVec_u64ZZ;
class CVec_UpdateFulfillHTLCZ;
-class CResult_BlindedRouteNoneZ;
+class CVec_C2Tuple_u32CVec_u8ZZZ;
+class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ;
class CResult_AnnouncementSignaturesDecodeErrorZ;
+class CResult_TxCompleteDecodeErrorZ;
class CResult_UpdateFulfillHTLCDecodeErrorZ;
-class CResult_ChannelUpdateDecodeErrorZ;
class CResult_NodeFeaturesDecodeErrorZ;
-class CVec_u5Z;
class CResult_InMemorySignerDecodeErrorZ;
-class CResult_PaymentSecretAPIErrorZ;
+class CResult_TxSignaturesDecodeErrorZ;
+class CVec_HTLCDescriptorZ;
+class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
+class COption_PathFailureZ;
+class COption_MessageContextZ;
+class CVec_ECDSASignatureZ;
+class CResult_ChannelUpdateInfoDecodeErrorZ;
+class CVec_UpdateFailHTLCZ;
+class CVec_TxOutZ;
+class CVec_InboundHTLCDetailsZ;
+class CVec_OutboundHTLCDetailsZ;
+class CResult_BuiltCommitmentTransactionDecodeErrorZ;
+class CVec_PaymentForwardNodeZ;
+class CResult_TrackedSpendableOutputDecodeErrorZ;
+class CVec_SpendableOutputDescriptorZ;
+class CResult_ResponderDecodeErrorZ;
+class C2Tuple_OutPointCVec_u8ZZ;
+class CResult_WitnessNoneZ;
+class COption_C2Tuple_u64u64ZZ;
+class CResult_ChannelAnnouncementDecodeErrorZ;
+class CResult_HTLCUpdateDecodeErrorZ;
+class CResult_TxAddInputDecodeErrorZ;
+class CResult_HeldHtlcAvailableDecodeErrorZ;
+class CResult_TxInitRbfDecodeErrorZ;
+class COption_WriteableScoreZ;
+class CVec_StrZ;
+class CResult_AsyncPaymentsMessageDecodeErrorZ;
+class CResult_SpliceAckDecodeErrorZ;
+class CResult_PositiveTimestampCreationErrorZ;
+class CResult_PeeledOnionNoneZ;
+class CVec_C2Tuple_OutPointChannelIdZZ;
+class CResult_ChannelMonitorUpdateDecodeErrorZ;
+class CResult_ReplyChannelRangeDecodeErrorZ;
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
+class CResult_TrustedClosingTransactionNoneZ;
+class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
+class C2Tuple_PublicKeyTypeZ;
+class CResult_TxRemoveOutputDecodeErrorZ;
+class CResult_ChannelReestablishDecodeErrorZ;
+class CResult_OnionMessageDecodeErrorZ;
+class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
+class CResult_MessageContextDecodeErrorZ;
+class CResult_InitFeaturesDecodeErrorZ;
+class CResult_PublicKeyNoneZ;
+class CResult_PingDecodeErrorZ;
+class CResult_RevocationKeyDecodeErrorZ;
+class C2Tuple_OffersMessageMessageSendInstructionsZ;
+class CResult_BlindedHopFeaturesDecodeErrorZ;
+class CResult_ChannelIdDecodeErrorZ;
+class CVec_TransactionOutputsZ;
+class COption_HTLCClaimZ;
+class COption_boolZ;
+class CVec_BlindedPaymentPathZ;
+class CResult_ProbabilisticScorerDecodeErrorZ;
+class COption_StrZ;
+class CResult_CVec_BlindedPaymentPathZNoneZ;
+class COption_C2Tuple_OffersMessageResponseInstructionZZ;
+class C2Tuple_usizeTransactionZ;
+class COption_OffersContextZ;
+class CResult_NodeAnnouncementDecodeErrorZ;
+class CVec_ChannelMonitorZ;
+class CResult_AcceptChannelV2DecodeErrorZ;
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ;
+class CResult_RouteHopDecodeErrorZ;
+class CResult_OfferIdDecodeErrorZ;
+class CVec_HTLCOutputInCommitmentZ;
+class CResult_CoinSelectionNoneZ;
+class CVec_FutureZ;
+class CResult_TxCreationKeysDecodeErrorZ;
+class CResult_RefundBolt12SemanticErrorZ;
+class CResult_NoneIOErrorZ;
+class CResult_MaxDustHTLCExposureDecodeErrorZ;
+class CVec_BalanceZ;
+class CVec_CommitmentTransactionZ;
+class CResult_FundingSignedDecodeErrorZ;
+class CResult_RecoverableSignatureNoneZ;
+class CResult_SocketAddressDecodeErrorZ;
+class C2Tuple_Z;
+class CResult_ShutdownScriptDecodeErrorZ;
+class CResult_InboundHTLCDetailsDecodeErrorZ;
+class CResult_SiPrefixBolt11ParseErrorZ;
+class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
+class CVec_PathZ;
+class CResult_NetworkGraphDecodeErrorZ;
+class CResult_NodeInfoDecodeErrorZ;
+class CVec_NodeIdZ;
+class CVec_u8Z;
+class CResult_RouteLightningErrorZ;
+class CResult_NonePaymentSendFailureZ;
+class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
+class CResult_ChannelPublicKeysDecodeErrorZ;
+class CVec_ClaimedHTLCZ;
+class COption_CVec_ThirtyTwoBytesZZ;
+class CVec_SocketAddressZ;
+class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ;
+class CResult_ThirtyTwoBytesPaymentSendFailureZ;
+class CResult_WarningMessageDecodeErrorZ;
+class CResult_ChannelCounterpartyDecodeErrorZ;
+class CResult_HolderCommitmentTransactionDecodeErrorZ;
+class CResult_DelayedPaymentKeyDecodeErrorZ;
+class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
+class CResult_OfferBolt12SemanticErrorZ;
+class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
+class CResult_InitDecodeErrorZ;
+class CResult_PaymentPurposeDecodeErrorZ;
+class CResult_ClaimedHTLCDecodeErrorZ;
+class CResult_OutPointDecodeErrorZ;
+class CVec_ChannelDetailsZ;
+class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
+class CVec_MessageSendEventZ;
+class CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ;
+class CResult_RouteHintHopDecodeErrorZ;
+class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ;
+class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
+class CResult_BlindedPayInfoDecodeErrorZ;
+class CResult_ThirtyTwoBytesAPIErrorZ;
+class COption_ChannelShutdownStateZ;
+class CResult_Bolt12InvoiceBolt12SemanticErrorZ;
+class CResult_InvoiceRequestFieldsDecodeErrorZ;
+class CResult_AcceptChannelDecodeErrorZ;
+class CResult_RefundDecodeErrorZ;
+class CResult_HostnameDecodeErrorZ;
+class C2Tuple_u64u16Z;
+class COption_ThirtyTwoBytesZ;
+class CVec_u64Z;
+class CResult_NoneBolt12SemanticErrorZ;
+class CResult_UnknownPaymentContextDecodeErrorZ;
+class COption_InboundHTLCStateDetailsZ;
+class CResult_OutputSweeperDecodeErrorZ;
+class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
+class COption_EventZ;
+class CResult_ChannelTypeFeaturesDecodeErrorZ;
+class COption_CVec_SocketAddressZZ;
+class CVec_RouteHintZ;
+class COption_u16Z;
+class COption_PaymentFailureReasonZ;
+class CResult_Bolt12RefundContextDecodeErrorZ;
+class CResult_ECDSASignatureNoneZ;
+class C2Tuple_ChannelIdPublicKeyZ;
+class C2Tuple_OffersMessageResponseInstructionZ;
+class CResult_EcdsaChannelSignerDecodeErrorZ;
+class CResult_BlindedTailDecodeErrorZ;
+class CVec_WitnessZ;
+class COption_C2Tuple_u64u16ZZ;
+class CResult_SocketAddressSocketAddressParseErrorZ;
+class CResult_COption_PaymentFailureReasonZDecodeErrorZ;
+class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
+class CResult_ChannelDerivationParametersDecodeErrorZ;
+class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
+class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ;
+class CResult_OnionMessagePathNoneZ;
+class C2Tuple_u32CVec_u8ZZ;
+class CVec_C2Tuple_PublicKeyTypeZZ;
+class CResult_OutboundHTLCDetailsDecodeErrorZ;
+class CResult_RefundBolt12ParseErrorZ;
+class CResult_u32GraphSyncErrorZ;
+class CVec_C2Tuple_u64CVec_u8ZZZ;
+class CResult_OffersMessageDecodeErrorZ;
+class CResult_PaymentConstraintsDecodeErrorZ;
+class CResult_NoneAPIErrorZ;
+class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
+class COption_f64Z;
+class CResult_TxRemoveInputDecodeErrorZ;
+class CVec_PublicKeyZ;
+class C2Tuple_CVec_u8Zu64Z;
+class CVec_C2Tuple_usizeTransactionZZ;
+class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
+class CResult_Bolt12InvoiceDecodeErrorZ;
+class C2Tuple_u64u64Z;
+class COption_NodeAnnouncementInfoZ;
+class CResult_PendingHTLCRoutingDecodeErrorZ;
+class COption_C2Tuple_OnionMessageContentsResponseInstructionZZ;
+class CResult_RecipientOnionFieldsDecodeErrorZ;
+class C2Tuple_u32TxOutZ;
+class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ;
+class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ;
+class CResult_ChannelDetailsDecodeErrorZ;
+class CVec_UtxoZ;
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
+class CResult_ChannelConfigDecodeErrorZ;
+class CVec_PrivateRouteZ;
+class COption_i64Z;
+class CResult_PaymentContextDecodeErrorZ;
+class CVec_PhantomRouteHintsZ;
+class CVec_C2Tuple_OutPointCVec_u64ZZZ;
+class C2Tuple_ThirtyTwoBytesChannelManagerZ;
+class CResult_COption_OnionMessageContentsZDecodeErrorZ;
+class C2Tuple_u64CVec_u8ZZ;
+class CResult_OfferBolt12ParseErrorZ;
+class CResult_ThirtyTwoBytesRetryableSendFailureZ;
+class CVec_MonitorEventZ;
+class CResult_ShutdownDecodeErrorZ;
+class CResult_BigSizeDecodeErrorZ;
+class CResult_TxOutUtxoLookupErrorZ;
+class COption_usizeZ;
+class CVec_BlindedMessagePathZ;
+class CResult_OffersContextDecodeErrorZ;
+class CResult_NoneNoneZ;
+class CResult_boolPeerHandleErrorZ;
+class CResult_ChannelUpdateDecodeErrorZ;
+class CVec_APIErrorZ;
+class COption_TxOutZ;
+class COption_ClosureReasonZ;
+class CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ;
+class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
+class CResult_TransactionU16LenLimitedDecodeErrorZ;
+class CResult_FundingInfoDecodeErrorZ;
+class COption_AmountZ;
+class COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ;
+class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
+class CResult_OpenChannelV2DecodeErrorZ;
+class CResult_BestBlockDecodeErrorZ;
+class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
class CResult_CounterpartyForwardingInfoDecodeErrorZ;
-class COption_ScalarZ;
-class CResult_SignedRawInvoiceParseErrorZ;
+class CResult_OutputSpendStatusDecodeErrorZ;
+class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ;
class CResult_RouteDecodeErrorZ;
-class CResult_BuiltCommitmentTransactionDecodeErrorZ;
+class CResult_BlindedFailureDecodeErrorZ;
+class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
class COption_NoneZ;
-class CVec_TxOutZ;
-class CResult_ChannelUpdateInfoDecodeErrorZ;
-class C2Tuple_u32ScriptZ;
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ;
-class CVec_UpdateFailHTLCZ;
-class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
+class CResult_SpliceLockedDecodeErrorZ;
+class COption_CVec_u8ZZ;
+class COption_QuantityZ;
+class CResult_TxAddOutputDecodeErrorZ;
+class CResult_HtlcBasepointDecodeErrorZ;
+class C2Tuple_OutPointChannelIdZ;
class Str {
private:
const LDKStr* operator &() const { return &self; }
const LDKStr* operator ->() const { return &self; }
};
-class BlindedRoute {
+class RefundMaybeWithDerivedMetadataBuilder {
private:
- LDKBlindedRoute self;
+ LDKRefundMaybeWithDerivedMetadataBuilder self;
public:
- BlindedRoute(const BlindedRoute&) = delete;
- BlindedRoute(BlindedRoute&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedRoute)); }
- BlindedRoute(LDKBlindedRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedRoute)); }
- operator LDKBlindedRoute() && { LDKBlindedRoute res = self; memset(&self, 0, sizeof(LDKBlindedRoute)); return res; }
- ~BlindedRoute() { BlindedRoute_free(self); }
- BlindedRoute& operator=(BlindedRoute&& o) { BlindedRoute_free(self); self = o.self; memset(&o, 0, sizeof(BlindedRoute)); return *this; }
- LDKBlindedRoute* operator &() { return &self; }
- LDKBlindedRoute* operator ->() { return &self; }
- const LDKBlindedRoute* operator &() const { return &self; }
- const LDKBlindedRoute* operator ->() const { return &self; }
+ RefundMaybeWithDerivedMetadataBuilder(const RefundMaybeWithDerivedMetadataBuilder&) = delete;
+ RefundMaybeWithDerivedMetadataBuilder(RefundMaybeWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); }
+ RefundMaybeWithDerivedMetadataBuilder(LDKRefundMaybeWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); }
+ operator LDKRefundMaybeWithDerivedMetadataBuilder() && { LDKRefundMaybeWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKRefundMaybeWithDerivedMetadataBuilder)); return res; }
+ ~RefundMaybeWithDerivedMetadataBuilder() { RefundMaybeWithDerivedMetadataBuilder_free(self); }
+ RefundMaybeWithDerivedMetadataBuilder& operator=(RefundMaybeWithDerivedMetadataBuilder&& o) { RefundMaybeWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(RefundMaybeWithDerivedMetadataBuilder)); return *this; }
+ LDKRefundMaybeWithDerivedMetadataBuilder* operator &() { return &self; }
+ LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() { return &self; }
+ const LDKRefundMaybeWithDerivedMetadataBuilder* operator &() const { return &self; }
+ const LDKRefundMaybeWithDerivedMetadataBuilder* operator ->() const { return &self; }
};
-class BlindedHop {
+class Refund {
private:
- LDKBlindedHop self;
+ LDKRefund 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; }
+ Refund(const Refund&) = delete;
+ Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
+ Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
+ operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
+ ~Refund() { Refund_free(self); }
+ Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
+ LDKRefund* operator &() { return &self; }
+ LDKRefund* operator ->() { return &self; }
+ const LDKRefund* operator &() const { return &self; }
+ const LDKRefund* operator ->() const { return &self; }
};
-class CounterpartyCommitmentSecrets {
+class Retry {
private:
- LDKCounterpartyCommitmentSecrets self;
+ LDKRetry 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; }
+ Retry(const Retry&) = delete;
+ Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
+ Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
+ operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
+ ~Retry() { Retry_free(self); }
+ Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
+ LDKRetry* operator &() { return &self; }
+ LDKRetry* operator ->() { return &self; }
+ const LDKRetry* operator &() const { return &self; }
+ const LDKRetry* operator ->() const { return &self; }
};
-class TxCreationKeys {
+class RetryableSendFailure {
private:
- LDKTxCreationKeys self;
+ LDKRetryableSendFailure 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; }
+ RetryableSendFailure(const RetryableSendFailure&) = delete;
+ RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
+ RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
+ operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
+ RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
+ LDKRetryableSendFailure* operator &() { return &self; }
+ LDKRetryableSendFailure* operator ->() { return &self; }
+ const LDKRetryableSendFailure* operator &() const { return &self; }
+ const LDKRetryableSendFailure* operator ->() const { return &self; }
};
-class ChannelPublicKeys {
+class PaymentSendFailure {
private:
- LDKChannelPublicKeys self;
+ LDKPaymentSendFailure 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; }
+ PaymentSendFailure(const PaymentSendFailure&) = delete;
+ PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
+ PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
+ operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
+ ~PaymentSendFailure() { PaymentSendFailure_free(self); }
+ PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
+ LDKPaymentSendFailure* operator &() { return &self; }
+ LDKPaymentSendFailure* operator ->() { return &self; }
+ const LDKPaymentSendFailure* operator &() const { return &self; }
+ const LDKPaymentSendFailure* operator ->() const { return &self; }
};
-class 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 Bolt12PaymentError {
+private:
+ LDKBolt12PaymentError self;
+public:
+ Bolt12PaymentError(const Bolt12PaymentError&) = delete;
+ Bolt12PaymentError(Bolt12PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12PaymentError)); }
+ Bolt12PaymentError(LDKBolt12PaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12PaymentError)); }
+ operator LDKBolt12PaymentError() && { LDKBolt12PaymentError res = self; memset(&self, 0, sizeof(LDKBolt12PaymentError)); return res; }
+ ~Bolt12PaymentError() { Bolt12PaymentError_free(self); }
+ Bolt12PaymentError& operator=(Bolt12PaymentError&& o) { Bolt12PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12PaymentError)); return *this; }
+ LDKBolt12PaymentError* operator &() { return &self; }
+ LDKBolt12PaymentError* operator ->() { return &self; }
+ const LDKBolt12PaymentError* operator &() const { return &self; }
+ const LDKBolt12PaymentError* operator ->() const { return &self; }
+};
+class ProbeSendFailure {
+private:
+ LDKProbeSendFailure self;
+public:
+ ProbeSendFailure(const ProbeSendFailure&) = delete;
+ ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
+ ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
+ operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
+ ~ProbeSendFailure() { ProbeSendFailure_free(self); }
+ ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
+ LDKProbeSendFailure* operator &() { return &self; }
+ LDKProbeSendFailure* operator ->() { return &self; }
+ const LDKProbeSendFailure* operator &() const { return &self; }
+ const LDKProbeSendFailure* operator ->() const { return &self; }
+};
+class RecipientOnionFields {
+private:
+ LDKRecipientOnionFields self;
+public:
+ RecipientOnionFields(const RecipientOnionFields&) = delete;
+ RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
+ RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
+ operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
+ ~RecipientOnionFields() { RecipientOnionFields_free(self); }
+ RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
+ LDKRecipientOnionFields* operator &() { return &self; }
+ LDKRecipientOnionFields* operator ->() { return &self; }
+ const LDKRecipientOnionFields* operator &() const { return &self; }
+ const LDKRecipientOnionFields* operator ->() const { return &self; }
+};
+class InvoiceWithExplicitSigningPubkeyBuilder {
+private:
+ LDKInvoiceWithExplicitSigningPubkeyBuilder self;
+public:
+ InvoiceWithExplicitSigningPubkeyBuilder(const InvoiceWithExplicitSigningPubkeyBuilder&) = delete;
+ InvoiceWithExplicitSigningPubkeyBuilder(InvoiceWithExplicitSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); }
+ InvoiceWithExplicitSigningPubkeyBuilder(LDKInvoiceWithExplicitSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); }
+ operator LDKInvoiceWithExplicitSigningPubkeyBuilder() && { LDKInvoiceWithExplicitSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithExplicitSigningPubkeyBuilder)); return res; }
+ ~InvoiceWithExplicitSigningPubkeyBuilder() { InvoiceWithExplicitSigningPubkeyBuilder_free(self); }
+ InvoiceWithExplicitSigningPubkeyBuilder& operator=(InvoiceWithExplicitSigningPubkeyBuilder&& o) { InvoiceWithExplicitSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithExplicitSigningPubkeyBuilder)); return *this; }
+ LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() { return &self; }
+ LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() { return &self; }
+ const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator &() const { return &self; }
+ const LDKInvoiceWithExplicitSigningPubkeyBuilder* operator ->() const { return &self; }
+};
+class InvoiceWithDerivedSigningPubkeyBuilder {
+private:
+ LDKInvoiceWithDerivedSigningPubkeyBuilder self;
+public:
+ InvoiceWithDerivedSigningPubkeyBuilder(const InvoiceWithDerivedSigningPubkeyBuilder&) = delete;
+ InvoiceWithDerivedSigningPubkeyBuilder(InvoiceWithDerivedSigningPubkeyBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); }
+ InvoiceWithDerivedSigningPubkeyBuilder(LDKInvoiceWithDerivedSigningPubkeyBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); }
+ operator LDKInvoiceWithDerivedSigningPubkeyBuilder() && { LDKInvoiceWithDerivedSigningPubkeyBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceWithDerivedSigningPubkeyBuilder)); return res; }
+ ~InvoiceWithDerivedSigningPubkeyBuilder() { InvoiceWithDerivedSigningPubkeyBuilder_free(self); }
+ InvoiceWithDerivedSigningPubkeyBuilder& operator=(InvoiceWithDerivedSigningPubkeyBuilder&& o) { InvoiceWithDerivedSigningPubkeyBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceWithDerivedSigningPubkeyBuilder)); return *this; }
+ LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() { return &self; }
+ LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() { return &self; }
+ const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator &() const { return &self; }
+ const LDKInvoiceWithDerivedSigningPubkeyBuilder* operator ->() const { return &self; }
+};
+class UnsignedBolt12Invoice {
+private:
+ LDKUnsignedBolt12Invoice self;
+public:
+ UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
+ UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
+ UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
+ operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
+ ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
+ UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
+ LDKUnsignedBolt12Invoice* operator &() { return &self; }
+ LDKUnsignedBolt12Invoice* operator ->() { return &self; }
+ const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
+ const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
+};
+class SignBolt12InvoiceFn {
+private:
+ LDKSignBolt12InvoiceFn self;
+public:
+ SignBolt12InvoiceFn(const SignBolt12InvoiceFn&) = delete;
+ SignBolt12InvoiceFn(SignBolt12InvoiceFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignBolt12InvoiceFn)); }
+ SignBolt12InvoiceFn(LDKSignBolt12InvoiceFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignBolt12InvoiceFn)); }
+ operator LDKSignBolt12InvoiceFn() && { LDKSignBolt12InvoiceFn res = self; memset(&self, 0, sizeof(LDKSignBolt12InvoiceFn)); return res; }
+ ~SignBolt12InvoiceFn() { SignBolt12InvoiceFn_free(self); }
+ SignBolt12InvoiceFn& operator=(SignBolt12InvoiceFn&& o) { SignBolt12InvoiceFn_free(self); self = o.self; memset(&o, 0, sizeof(SignBolt12InvoiceFn)); return *this; }
+ LDKSignBolt12InvoiceFn* operator &() { return &self; }
+ LDKSignBolt12InvoiceFn* operator ->() { return &self; }
+ const LDKSignBolt12InvoiceFn* operator &() const { return &self; }
+ const LDKSignBolt12InvoiceFn* operator ->() const { return &self; }
+ /**
+ * Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message);
};
-class ChannelTransactionParameters {
+class Bolt12Invoice {
private:
- LDKChannelTransactionParameters self;
+ LDKBolt12Invoice 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; }
+ Bolt12Invoice(const Bolt12Invoice&) = delete;
+ Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
+ Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
+ operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
+ ~Bolt12Invoice() { Bolt12Invoice_free(self); }
+ Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
+ LDKBolt12Invoice* operator &() { return &self; }
+ LDKBolt12Invoice* operator ->() { return &self; }
+ const LDKBolt12Invoice* operator &() const { return &self; }
+ const LDKBolt12Invoice* operator ->() const { return &self; }
};
-class CounterpartyChannelTransactionParameters {
+class DelayedPaymentOutputDescriptor {
private:
- LDKCounterpartyChannelTransactionParameters self;
+ LDKDelayedPaymentOutputDescriptor 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; }
+ DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
+ DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
+ DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
+ operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
+ ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
+ DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
+ LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
+ LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
+ const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
+ const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
};
-class DirectedChannelTransactionParameters {
+class StaticPaymentOutputDescriptor {
private:
- LDKDirectedChannelTransactionParameters self;
+ LDKStaticPaymentOutputDescriptor 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; }
+ StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
+ StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
+ StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
+ operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
+ ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
+ StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
+ LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
+ LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
+ const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
+ const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
};
-class HolderCommitmentTransaction {
+class SpendableOutputDescriptor {
private:
- LDKHolderCommitmentTransaction self;
+ LDKSpendableOutputDescriptor 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; }
+ SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
+ SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
+ SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
+ operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
+ ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
+ SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
+ LDKSpendableOutputDescriptor* operator &() { return &self; }
+ LDKSpendableOutputDescriptor* operator ->() { return &self; }
+ const LDKSpendableOutputDescriptor* operator &() const { return &self; }
+ const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
+};
+class ChannelDerivationParameters {
+private:
+ LDKChannelDerivationParameters self;
+public:
+ ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
+ ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
+ ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
+ operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
+ ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
+ ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
+ LDKChannelDerivationParameters* operator &() { return &self; }
+ LDKChannelDerivationParameters* operator ->() { return &self; }
+ const LDKChannelDerivationParameters* operator &() const { return &self; }
+ const LDKChannelDerivationParameters* operator ->() const { return &self; }
+};
+class HTLCDescriptor {
+private:
+ LDKHTLCDescriptor self;
+public:
+ HTLCDescriptor(const HTLCDescriptor&) = delete;
+ HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
+ HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
+ operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
+ ~HTLCDescriptor() { HTLCDescriptor_free(self); }
+ HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
+ LDKHTLCDescriptor* operator &() { return &self; }
+ LDKHTLCDescriptor* operator ->() { return &self; }
+ const LDKHTLCDescriptor* operator &() const { return &self; }
+ const LDKHTLCDescriptor* operator ->() const { return &self; }
+};
+class ChannelSigner {
+private:
+ LDKChannelSigner self;
+public:
+ ChannelSigner(const ChannelSigner&) = delete;
+ ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
+ ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
+ operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
+ ~ChannelSigner() { ChannelSigner_free(self); }
+ ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
+ LDKChannelSigner* operator &() { return &self; }
+ LDKChannelSigner* operator ->() { return &self; }
+ const LDKChannelSigner* operator &() const { return &self; }
+ const LDKChannelSigner* operator ->() const { return &self; }
+ /**
+ * Gets the per-commitment point for a specific commitment number
+ *
+ * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
+ *
+ * If the signer returns `Err`, then the user is responsible for either force-closing the channel
+ * or calling `ChannelManager::signer_unblocked` (this method is only available when the
+ * `async_signing` cfg flag is enabled) once the signature is ready.
+ *
+ */
+ inline LDK::CResult_PublicKeyNoneZ get_per_commitment_point(uint64_t idx);
+ /**
+ * Gets the commitment secret for a specific commitment number as part of the revocation process
+ *
+ * An external signer implementation should error here if the commitment was already signed
+ * and should refuse to sign it in the future.
+ *
+ * May be called more than once for the same index.
+ *
+ * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
+ */
+ inline LDK::CResult__u832NoneZ release_commitment_secret(uint64_t idx);
+ /**
+ * Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
+ *
+ * This is required in order for the signer to make sure that releasing a commitment
+ * secret won't leave us without a broadcastable holder transaction.
+ * Policy checks should be implemented in this function, including checking the amount
+ * sent to us and checking the HTLCs.
+ *
+ * The preimages of outbound HTLCs that were fulfilled since the last commitment are provided.
+ * A validating signer should ensure that an HTLC output is removed only when the matching
+ * preimage is provided, or when the value to holder is restored.
+ *
+ * Note that all the relevant preimages will be provided, but there may also be additional
+ * irrelevant or duplicate preimages.
+ */
+ inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
+ /**
+ * Validate the counterparty's revocation.
+ *
+ * This is required in order for the signer to make sure that the state has moved
+ * forward and it is safe to sign the next counterparty commitment.
+ */
+ inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
+ /**
+ * Returns an arbitrary identifier describing the set of keys which are provided back to you in
+ * some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
+ * [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
+ */
+ inline LDKThirtyTwoBytes channel_keys_id();
+ /**
+ * Set the counterparty static channel data, including basepoints,
+ * `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
+ *
+ * This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
+ * instance, LDK will call this method exactly once - either immediately after construction
+ * (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
+ * information has been generated.
+ *
+ * channel_parameters.is_populated() MUST be true.
+ */
+ inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+};
+class Recipient {
+private:
+ LDKRecipient self;
+public:
+ Recipient(const Recipient&) = delete;
+ Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
+ Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
+ operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
+ Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
+ LDKRecipient* operator &() { return &self; }
+ LDKRecipient* operator ->() { return &self; }
+ const LDKRecipient* operator &() const { return &self; }
+ const LDKRecipient* operator ->() const { return &self; }
+};
+class EntropySource {
+private:
+ LDKEntropySource self;
+public:
+ EntropySource(const EntropySource&) = delete;
+ EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
+ EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
+ operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
+ ~EntropySource() { EntropySource_free(self); }
+ EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
+ LDKEntropySource* operator &() { return &self; }
+ LDKEntropySource* operator ->() { return &self; }
+ const LDKEntropySource* operator &() const { return &self; }
+ const LDKEntropySource* operator ->() const { return &self; }
+ /**
+ * Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
+ * different value each time it is called.
+ */
+ inline LDKThirtyTwoBytes get_secure_random_bytes();
+};
+class NodeSigner {
+private:
+ LDKNodeSigner self;
+public:
+ NodeSigner(const NodeSigner&) = delete;
+ NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
+ NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
+ operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
+ ~NodeSigner() { NodeSigner_free(self); }
+ NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
+ LDKNodeSigner* operator &() { return &self; }
+ LDKNodeSigner* operator ->() { return &self; }
+ const LDKNodeSigner* operator &() const { return &self; }
+ const LDKNodeSigner* operator ->() const { return &self; }
+ /**
+ * Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
+ *
+ * If the implementor of this trait supports [phantom node payments], then every node that is
+ * intended to be included in the phantom invoice route hints must return the same value from
+ * this method.
+ *
+ * This method must return the same value each time it is called.
+ *
+ * [phantom node payments]: PhantomKeysManager
+ */
+ inline LDKThirtyTwoBytes get_inbound_payment_key_material();
+ /**
+ * Get node id based on the provided [`Recipient`].
+ *
+ * This method must return the same value each time it is called with a given [`Recipient`]
+ * parameter.
+ *
+ * Errors if the [`Recipient`] variant is not supported by the implementation.
+ */
+ inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
+ /**
+ * Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
+ * one is provided. Note that this tweak can be applied to `other_key` instead of our node
+ * secret, though this is less efficient.
+ *
+ * Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
+ * should be resolved to allow LDK to resume forwarding HTLCs.
+ *
+ * Errors if the [`Recipient`] variant is not supported by the implementation.
+ */
+ inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
+ /**
+ * Sign an invoice.
+ *
+ * By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
+ * this trait to parse the invoice and make sure they're signing what they expect, rather than
+ * blindly signing the hash.
+ *
+ * The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
+ *
+ * The secret key used to sign the invoice is dependent on the [`Recipient`].
+ *
+ * Errors if the [`Recipient`] variant is not supported by the implementation.
+ */
+ inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(const struct LDKRawBolt11Invoice *NONNULL_PTR invoice, enum LDKRecipient recipient);
+ /**
+ * Signs the [`TaggedHash`] of a BOLT 12 invoice request.
+ *
+ * May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
+ * `invoice_request` is the callee.
+ *
+ * Implementors may check that the `invoice_request` is expected rather than blindly signing
+ * the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
+ * the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
+ * [`UnsignedInvoiceRequest::payer_id`].
+ *
+ * [`TaggedHash`]: crate::offers::merkle::TaggedHash
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
+ /**
+ * Signs the [`TaggedHash`] of a BOLT 12 invoice.
+ *
+ * May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
+ * callee.
+ *
+ * Implementors may check that the `invoice` is expected rather than blindly signing the tagged
+ * hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
+ * key or an ephemeral key to preserve privacy, whichever is associated with
+ * [`UnsignedBolt12Invoice::signing_pubkey`].
+ *
+ * [`TaggedHash`]: crate::offers::merkle::TaggedHash
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
+ /**
+ * Sign a gossip message.
+ *
+ * Note that if this fails, LDK may panic and the message will not be broadcast to the network
+ * or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
+ * message to be broadcast, as otherwise it may prevent one from receiving funds over the
+ * corresponding channel.
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
+};
+class OutputSpender {
+private:
+ LDKOutputSpender self;
+public:
+ OutputSpender(const OutputSpender&) = delete;
+ OutputSpender(OutputSpender&& o) : self(o.self) { memset(&o, 0, sizeof(OutputSpender)); }
+ OutputSpender(LDKOutputSpender&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutputSpender)); }
+ operator LDKOutputSpender() && { LDKOutputSpender res = self; memset(&self, 0, sizeof(LDKOutputSpender)); return res; }
+ ~OutputSpender() { OutputSpender_free(self); }
+ OutputSpender& operator=(OutputSpender&& o) { OutputSpender_free(self); self = o.self; memset(&o, 0, sizeof(OutputSpender)); return *this; }
+ LDKOutputSpender* operator &() { return &self; }
+ LDKOutputSpender* operator ->() { return &self; }
+ const LDKOutputSpender* operator &() const { return &self; }
+ const LDKOutputSpender* operator ->() const { return &self; }
+ /**
+ * Creates a [`Transaction`] which spends the given descriptors to the given outputs, plus an
+ * output to the given change destination (if sufficient change value remains). The
+ * transaction will have a feerate, at least, of the given value.
+ *
+ * The `locktime` argument is used to set the transaction's locktime. If `None`, the
+ * transaction will have a locktime of 0. It it recommended to set this to the current block
+ * height to avoid fee sniping, unless you have some specific reason to use a different
+ * locktime.
+ *
+ * Returns `Err(())` if the output value is greater than the input value minus required fee,
+ * if a descriptor was duplicated, or if an output descriptor `script_pubkey`
+ * does not match the one we can spend.
+ */
+ inline LDK::CResult_TransactionNoneZ spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime);
+};
+class SignerProvider {
+private:
+ LDKSignerProvider self;
+public:
+ SignerProvider(const SignerProvider&) = delete;
+ SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
+ SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
+ operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
+ ~SignerProvider() { SignerProvider_free(self); }
+ SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
+ LDKSignerProvider* operator &() { return &self; }
+ LDKSignerProvider* operator ->() { return &self; }
+ const LDKSignerProvider* operator &() const { return &self; }
+ const LDKSignerProvider* operator ->() const { return &self; }
+ /**
+ * Generates a unique `channel_keys_id` that can be used to obtain a [`Self::EcdsaSigner`] through
+ * [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
+ * implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
+ * `channel_keys_id`.
+ *
+ * This method must return a different value each time it is called.
+ */
+ inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
+ /**
+ * Derives the private key material backing a `Signer`.
+ *
+ * To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
+ * [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
+ * re-derived from its `channel_keys_id`, which can be obtained through its trait method
+ * [`ChannelSigner::channel_keys_id`].
+ */
+ inline LDK::EcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
+ /**
+ * Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
+ * This is only called during deserialization of other objects which contain
+ * [`EcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
+ * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
+ * contain no versioning scheme. You may wish to include your own version prefix and ensure
+ * you've read all of the provided bytes to ensure no corruption occurred.
+ *
+ * This method is slowly being phased out -- it will only be called when reading objects
+ * written by LDK versions prior to 0.0.113.
+ *
+ * [`Signer`]: Self::EcdsaSigner
+ * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ */
+ inline LDK::CResult_EcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
+ /**
+ * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
+ *
+ * If this function returns an error, this will result in a channel failing to open.
+ *
+ * This method should return a different value each time it is called, to avoid linking
+ * on-chain funds across channels as controlled to the same user. `channel_keys_id` may be
+ * used to derive a unique value for each channel.
+ */
+ inline LDK::CResult_CVec_u8ZNoneZ get_destination_script(struct LDKThirtyTwoBytes channel_keys_id);
+ /**
+ * Get a script pubkey which we will send funds to when closing a channel.
+ *
+ * If this function returns an error, this will result in a channel failing to open or close.
+ * In the event of a failure when the counterparty is initiating a close, this can result in a
+ * channel force close.
+ *
+ * This method should return a different value each time it is called, to avoid linking
+ * on-chain funds across channels as controlled to the same user.
+ */
+ inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
+};
+class ChangeDestinationSource {
+private:
+ LDKChangeDestinationSource self;
+public:
+ ChangeDestinationSource(const ChangeDestinationSource&) = delete;
+ ChangeDestinationSource(ChangeDestinationSource&& o) : self(o.self) { memset(&o, 0, sizeof(ChangeDestinationSource)); }
+ ChangeDestinationSource(LDKChangeDestinationSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChangeDestinationSource)); }
+ operator LDKChangeDestinationSource() && { LDKChangeDestinationSource res = self; memset(&self, 0, sizeof(LDKChangeDestinationSource)); return res; }
+ ~ChangeDestinationSource() { ChangeDestinationSource_free(self); }
+ ChangeDestinationSource& operator=(ChangeDestinationSource&& o) { ChangeDestinationSource_free(self); self = o.self; memset(&o, 0, sizeof(ChangeDestinationSource)); return *this; }
+ LDKChangeDestinationSource* operator &() { return &self; }
+ LDKChangeDestinationSource* operator ->() { return &self; }
+ const LDKChangeDestinationSource* operator &() const { return &self; }
+ const LDKChangeDestinationSource* operator ->() const { return &self; }
+ /**
+ * Returns a script pubkey which can be used as a change destination for
+ * [`OutputSpender::spend_spendable_outputs`].
+ *
+ * This method should return a different value each time it is called, to avoid linking
+ * on-chain funds controlled to the same user.
+ */
+ inline LDK::CResult_CVec_u8ZNoneZ get_change_destination_script();
+};
+class InMemorySigner {
+private:
+ LDKInMemorySigner self;
+public:
+ InMemorySigner(const InMemorySigner&) = delete;
+ InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
+ InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
+ operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
+ ~InMemorySigner() { InMemorySigner_free(self); }
+ InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
+ LDKInMemorySigner* operator &() { return &self; }
+ LDKInMemorySigner* operator ->() { return &self; }
+ const LDKInMemorySigner* operator &() const { return &self; }
+ const LDKInMemorySigner* operator ->() const { return &self; }
+};
+class KeysManager {
+private:
+ LDKKeysManager self;
+public:
+ KeysManager(const KeysManager&) = delete;
+ KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
+ KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
+ operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
+ ~KeysManager() { KeysManager_free(self); }
+ KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
+ LDKKeysManager* operator &() { return &self; }
+ LDKKeysManager* operator ->() { return &self; }
+ const LDKKeysManager* operator &() const { return &self; }
+ const LDKKeysManager* operator ->() const { return &self; }
+};
+class PhantomKeysManager {
+private:
+ LDKPhantomKeysManager self;
+public:
+ PhantomKeysManager(const PhantomKeysManager&) = delete;
+ PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
+ PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
+ operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
+ ~PhantomKeysManager() { PhantomKeysManager_free(self); }
+ PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
+ LDKPhantomKeysManager* operator &() { return &self; }
+ LDKPhantomKeysManager* operator ->() { return &self; }
+ const LDKPhantomKeysManager* operator &() const { return &self; }
+ const LDKPhantomKeysManager* operator ->() const { return &self; }
+};
+class RandomBytes {
+private:
+ LDKRandomBytes self;
+public:
+ RandomBytes(const RandomBytes&) = delete;
+ RandomBytes(RandomBytes&& o) : self(o.self) { memset(&o, 0, sizeof(RandomBytes)); }
+ RandomBytes(LDKRandomBytes&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRandomBytes)); }
+ operator LDKRandomBytes() && { LDKRandomBytes res = self; memset(&self, 0, sizeof(LDKRandomBytes)); return res; }
+ ~RandomBytes() { RandomBytes_free(self); }
+ RandomBytes& operator=(RandomBytes&& o) { RandomBytes_free(self); self = o.self; memset(&o, 0, sizeof(RandomBytes)); return *this; }
+ LDKRandomBytes* operator &() { return &self; }
+ LDKRandomBytes* operator ->() { return &self; }
+ const LDKRandomBytes* operator &() const { return &self; }
+ const LDKRandomBytes* operator ->() const { return &self; }
+};
+class BackgroundProcessor {
+private:
+ LDKBackgroundProcessor self;
+public:
+ BackgroundProcessor(const BackgroundProcessor&) = delete;
+ BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
+ BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
+ operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
+ ~BackgroundProcessor() { BackgroundProcessor_free(self); }
+ BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
+ LDKBackgroundProcessor* operator &() { return &self; }
+ LDKBackgroundProcessor* operator ->() { return &self; }
+ const LDKBackgroundProcessor* operator &() const { return &self; }
+ const LDKBackgroundProcessor* operator ->() const { return &self; }
+};
+class GossipSync {
+private:
+ LDKGossipSync self;
+public:
+ GossipSync(const GossipSync&) = delete;
+ GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
+ GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
+ operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
+ ~GossipSync() { GossipSync_free(self); }
+ GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
+ LDKGossipSync* operator &() { return &self; }
+ LDKGossipSync* operator ->() { return &self; }
+ const LDKGossipSync* operator &() const { return &self; }
+ const LDKGossipSync* operator ->() const { return &self; }
+};
+class DefaultRouter {
+private:
+ LDKDefaultRouter self;
+public:
+ DefaultRouter(const DefaultRouter&) = delete;
+ DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
+ DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
+ operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
+ ~DefaultRouter() { DefaultRouter_free(self); }
+ DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
+ LDKDefaultRouter* operator &() { return &self; }
+ LDKDefaultRouter* operator ->() { return &self; }
+ const LDKDefaultRouter* operator &() const { return &self; }
+ const LDKDefaultRouter* operator ->() const { return &self; }
+};
+class Router {
+private:
+ LDKRouter self;
+public:
+ Router(const Router&) = delete;
+ Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
+ Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
+ operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
+ ~Router() { Router_free(self); }
+ Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
+ LDKRouter* operator &() { return &self; }
+ LDKRouter* operator ->() { return &self; }
+ const LDKRouter* operator &() const { return &self; }
+ const LDKRouter* operator ->() const { return &self; }
+ /**
+ * Finds a [`Route`] for a payment between the given `payer` and a payee.
+ *
+ * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
+ * and [`RouteParameters::final_value_msat`], respectively.
+ *
+ * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs);
+ /**
+ * Finds a [`Route`] for a payment between the given `payer` and a payee.
+ *
+ * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
+ * and [`RouteParameters::final_value_msat`], respectively.
+ *
+ * Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
+ * payment.
+ *
+ * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::CResult_RouteLightningErrorZ find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id);
+ /**
+ * Creates [`BlindedPaymentPath`]s for payment to the `recipient` node. The channels in `first_hops`
+ * are assumed to be with the `recipient`'s peers. The payment secret and any constraints are
+ * given in `tlvs`.
+ */
+ inline LDK::CResult_CVec_BlindedPaymentPathZNoneZ create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats);
+};
+class ScorerAccountingForInFlightHtlcs {
+private:
+ LDKScorerAccountingForInFlightHtlcs self;
+public:
+ ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
+ ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
+ ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
+ operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
+ ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
+ ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
+ LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
+ LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
+ const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
+ const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
+};
+class InFlightHtlcs {
+private:
+ LDKInFlightHtlcs self;
+public:
+ InFlightHtlcs(const InFlightHtlcs&) = delete;
+ InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
+ InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
+ operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
+ ~InFlightHtlcs() { InFlightHtlcs_free(self); }
+ InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
+ LDKInFlightHtlcs* operator &() { return &self; }
+ LDKInFlightHtlcs* operator ->() { return &self; }
+ const LDKInFlightHtlcs* operator &() const { return &self; }
+ const LDKInFlightHtlcs* operator ->() const { return &self; }
+};
+class RouteHop {
+private:
+ LDKRouteHop self;
+public:
+ RouteHop(const RouteHop&) = delete;
+ RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
+ RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
+ operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
+ ~RouteHop() { RouteHop_free(self); }
+ RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
+ LDKRouteHop* operator &() { return &self; }
+ LDKRouteHop* operator ->() { return &self; }
+ const LDKRouteHop* operator &() const { return &self; }
+ const LDKRouteHop* operator ->() const { return &self; }
+};
+class BlindedTail {
+private:
+ LDKBlindedTail self;
+public:
+ BlindedTail(const BlindedTail&) = delete;
+ BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
+ BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
+ operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
+ ~BlindedTail() { BlindedTail_free(self); }
+ BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
+ LDKBlindedTail* operator &() { return &self; }
+ LDKBlindedTail* operator ->() { return &self; }
+ const LDKBlindedTail* operator &() const { return &self; }
+ const LDKBlindedTail* operator ->() const { return &self; }
+};
+class Path {
+private:
+ LDKPath self;
+public:
+ Path(const Path&) = delete;
+ Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
+ Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
+ operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
+ ~Path() { Path_free(self); }
+ Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
+ LDKPath* operator &() { return &self; }
+ LDKPath* operator ->() { return &self; }
+ const LDKPath* operator &() const { return &self; }
+ const LDKPath* operator ->() const { return &self; }
+};
+class Route {
+private:
+ LDKRoute self;
+public:
+ Route(const Route&) = delete;
+ Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
+ Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
+ operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
+ ~Route() { Route_free(self); }
+ Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
+ LDKRoute* operator &() { return &self; }
+ LDKRoute* operator ->() { return &self; }
+ const LDKRoute* operator &() const { return &self; }
+ const LDKRoute* operator ->() const { return &self; }
+};
+class RouteParameters {
+private:
+ LDKRouteParameters self;
+public:
+ RouteParameters(const RouteParameters&) = delete;
+ RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
+ RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
+ operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
+ ~RouteParameters() { RouteParameters_free(self); }
+ RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
+ LDKRouteParameters* operator &() { return &self; }
+ LDKRouteParameters* operator ->() { return &self; }
+ const LDKRouteParameters* operator &() const { return &self; }
+ const LDKRouteParameters* operator ->() const { return &self; }
+};
+class PaymentParameters {
+private:
+ LDKPaymentParameters self;
+public:
+ PaymentParameters(const PaymentParameters&) = delete;
+ PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
+ PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
+ operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
+ ~PaymentParameters() { PaymentParameters_free(self); }
+ PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
+ LDKPaymentParameters* operator &() { return &self; }
+ LDKPaymentParameters* operator ->() { return &self; }
+ const LDKPaymentParameters* operator &() const { return &self; }
+ const LDKPaymentParameters* operator ->() const { return &self; }
+};
+class Payee {
+private:
+ LDKPayee self;
+public:
+ Payee(const Payee&) = delete;
+ Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
+ Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
+ operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
+ ~Payee() { Payee_free(self); }
+ Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
+ LDKPayee* operator &() { return &self; }
+ LDKPayee* operator ->() { return &self; }
+ const LDKPayee* operator &() const { return &self; }
+ const LDKPayee* operator ->() const { return &self; }
+};
+class FirstHopCandidate {
+private:
+ LDKFirstHopCandidate self;
+public:
+ FirstHopCandidate(const FirstHopCandidate&) = delete;
+ FirstHopCandidate(FirstHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(FirstHopCandidate)); }
+ FirstHopCandidate(LDKFirstHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFirstHopCandidate)); }
+ operator LDKFirstHopCandidate() && { LDKFirstHopCandidate res = self; memset(&self, 0, sizeof(LDKFirstHopCandidate)); return res; }
+ ~FirstHopCandidate() { FirstHopCandidate_free(self); }
+ FirstHopCandidate& operator=(FirstHopCandidate&& o) { FirstHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(FirstHopCandidate)); return *this; }
+ LDKFirstHopCandidate* operator &() { return &self; }
+ LDKFirstHopCandidate* operator ->() { return &self; }
+ const LDKFirstHopCandidate* operator &() const { return &self; }
+ const LDKFirstHopCandidate* operator ->() const { return &self; }
+};
+class PublicHopCandidate {
+private:
+ LDKPublicHopCandidate self;
+public:
+ PublicHopCandidate(const PublicHopCandidate&) = delete;
+ PublicHopCandidate(PublicHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PublicHopCandidate)); }
+ PublicHopCandidate(LDKPublicHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPublicHopCandidate)); }
+ operator LDKPublicHopCandidate() && { LDKPublicHopCandidate res = self; memset(&self, 0, sizeof(LDKPublicHopCandidate)); return res; }
+ ~PublicHopCandidate() { PublicHopCandidate_free(self); }
+ PublicHopCandidate& operator=(PublicHopCandidate&& o) { PublicHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PublicHopCandidate)); return *this; }
+ LDKPublicHopCandidate* operator &() { return &self; }
+ LDKPublicHopCandidate* operator ->() { return &self; }
+ const LDKPublicHopCandidate* operator &() const { return &self; }
+ const LDKPublicHopCandidate* operator ->() const { return &self; }
+};
+class PrivateHopCandidate {
+private:
+ LDKPrivateHopCandidate self;
+public:
+ PrivateHopCandidate(const PrivateHopCandidate&) = delete;
+ PrivateHopCandidate(PrivateHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateHopCandidate)); }
+ PrivateHopCandidate(LDKPrivateHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateHopCandidate)); }
+ operator LDKPrivateHopCandidate() && { LDKPrivateHopCandidate res = self; memset(&self, 0, sizeof(LDKPrivateHopCandidate)); return res; }
+ ~PrivateHopCandidate() { PrivateHopCandidate_free(self); }
+ PrivateHopCandidate& operator=(PrivateHopCandidate&& o) { PrivateHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PrivateHopCandidate)); return *this; }
+ LDKPrivateHopCandidate* operator &() { return &self; }
+ LDKPrivateHopCandidate* operator ->() { return &self; }
+ const LDKPrivateHopCandidate* operator &() const { return &self; }
+ const LDKPrivateHopCandidate* operator ->() const { return &self; }
+};
+class BlindedPathCandidate {
+private:
+ LDKBlindedPathCandidate self;
+public:
+ BlindedPathCandidate(const BlindedPathCandidate&) = delete;
+ BlindedPathCandidate(BlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPathCandidate)); }
+ BlindedPathCandidate(LDKBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPathCandidate)); }
+ operator LDKBlindedPathCandidate() && { LDKBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKBlindedPathCandidate)); return res; }
+ ~BlindedPathCandidate() { BlindedPathCandidate_free(self); }
+ BlindedPathCandidate& operator=(BlindedPathCandidate&& o) { BlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPathCandidate)); return *this; }
+ LDKBlindedPathCandidate* operator &() { return &self; }
+ LDKBlindedPathCandidate* operator ->() { return &self; }
+ const LDKBlindedPathCandidate* operator &() const { return &self; }
+ const LDKBlindedPathCandidate* operator ->() const { return &self; }
+};
+class OneHopBlindedPathCandidate {
+private:
+ LDKOneHopBlindedPathCandidate self;
+public:
+ OneHopBlindedPathCandidate(const OneHopBlindedPathCandidate&) = delete;
+ OneHopBlindedPathCandidate(OneHopBlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); }
+ OneHopBlindedPathCandidate(LDKOneHopBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOneHopBlindedPathCandidate)); }
+ operator LDKOneHopBlindedPathCandidate() && { LDKOneHopBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKOneHopBlindedPathCandidate)); return res; }
+ ~OneHopBlindedPathCandidate() { OneHopBlindedPathCandidate_free(self); }
+ OneHopBlindedPathCandidate& operator=(OneHopBlindedPathCandidate&& o) { OneHopBlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); return *this; }
+ LDKOneHopBlindedPathCandidate* operator &() { return &self; }
+ LDKOneHopBlindedPathCandidate* operator ->() { return &self; }
+ const LDKOneHopBlindedPathCandidate* operator &() const { return &self; }
+ const LDKOneHopBlindedPathCandidate* operator ->() const { return &self; }
+};
+class CandidateRouteHop {
+private:
+ LDKCandidateRouteHop self;
+public:
+ CandidateRouteHop(const CandidateRouteHop&) = delete;
+ CandidateRouteHop(CandidateRouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(CandidateRouteHop)); }
+ CandidateRouteHop(LDKCandidateRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCandidateRouteHop)); }
+ operator LDKCandidateRouteHop() && { LDKCandidateRouteHop res = self; memset(&self, 0, sizeof(LDKCandidateRouteHop)); return res; }
+ ~CandidateRouteHop() { CandidateRouteHop_free(self); }
+ CandidateRouteHop& operator=(CandidateRouteHop&& o) { CandidateRouteHop_free(self); self = o.self; memset(&o, 0, sizeof(CandidateRouteHop)); return *this; }
+ LDKCandidateRouteHop* operator &() { return &self; }
+ LDKCandidateRouteHop* operator ->() { return &self; }
+ const LDKCandidateRouteHop* operator &() const { return &self; }
+ const LDKCandidateRouteHop* operator ->() const { return &self; }
+};
+class UntrustedString {
+private:
+ LDKUntrustedString self;
+public:
+ UntrustedString(const UntrustedString&) = delete;
+ UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
+ UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
+ operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
+ ~UntrustedString() { UntrustedString_free(self); }
+ UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
+ LDKUntrustedString* operator &() { return &self; }
+ LDKUntrustedString* operator ->() { return &self; }
+ const LDKUntrustedString* operator &() const { return &self; }
+ const LDKUntrustedString* operator ->() const { return &self; }
+};
+class PrintableString {
+private:
+ LDKPrintableString self;
+public:
+ PrintableString(const PrintableString&) = delete;
+ PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
+ PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
+ operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
+ ~PrintableString() { PrintableString_free(self); }
+ PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
+ LDKPrintableString* operator &() { return &self; }
+ LDKPrintableString* operator ->() { return &self; }
+ const LDKPrintableString* operator &() const { return &self; }
+ const LDKPrintableString* operator ->() const { return &self; }
+};
+class ScoreLookUp {
+private:
+ LDKScoreLookUp self;
+public:
+ ScoreLookUp(const ScoreLookUp&) = delete;
+ ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
+ ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
+ operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
+ ~ScoreLookUp() { ScoreLookUp_free(self); }
+ ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
+ LDKScoreLookUp* operator &() { return &self; }
+ LDKScoreLookUp* operator ->() { return &self; }
+ const LDKScoreLookUp* operator &() const { return &self; }
+ const LDKScoreLookUp* operator ->() const { return &self; }
+ /**
+ * Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
+ * given channel in the direction from `source` to `target`.
+ *
+ * The channel's capacity (less any other MPP parts that are also being considered for use in
+ * the same payment) is given by `capacity_msat`. It may be determined from various sources
+ * such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
+ * [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
+ * Thus, implementations should be overflow-safe.
+ */
+ inline uint64_t channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
+};
+class ScoreUpdate {
+private:
+ LDKScoreUpdate self;
+public:
+ ScoreUpdate(const ScoreUpdate&) = delete;
+ ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
+ ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
+ operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
+ ~ScoreUpdate() { ScoreUpdate_free(self); }
+ ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
+ LDKScoreUpdate* operator &() { return &self; }
+ LDKScoreUpdate* operator ->() { return &self; }
+ const LDKScoreUpdate* operator &() const { return &self; }
+ const LDKScoreUpdate* operator ->() const { return &self; }
+ /**
+ * Handles updating channel penalties after failing to route through a channel.
+ */
+ inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
+ /**
+ * Handles updating channel penalties after successfully routing along a path.
+ */
+ inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
+ /**
+ * Handles updating channel penalties after a probe over the given path failed.
+ */
+ inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
+ /**
+ * Handles updating channel penalties after a probe over the given path succeeded.
+ */
+ inline void probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
+ /**
+ * Scorers may wish to reduce their certainty of channel liquidity information over time.
+ * Thus, this method is provided to allow scorers to observe the passage of time - the holder
+ * of this object should call this method regularly (generally via the
+ * `lightning-background-processor` crate).
+ */
+ inline void time_passed(uint64_t duration_since_epoch);
+};
+class Score {
+private:
+ LDKScore self;
+public:
+ Score(const Score&) = delete;
+ Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
+ Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
+ operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
+ ~Score() { Score_free(self); }
+ Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
+ LDKScore* operator &() { return &self; }
+ LDKScore* operator ->() { return &self; }
+ const LDKScore* operator &() const { return &self; }
+ const LDKScore* operator ->() const { return &self; }
+};
+class LockableScore {
+private:
+ LDKLockableScore self;
+public:
+ LockableScore(const LockableScore&) = delete;
+ LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
+ LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
+ operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
+ ~LockableScore() { LockableScore_free(self); }
+ LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
+ LDKLockableScore* operator &() { return &self; }
+ LDKLockableScore* operator ->() { return &self; }
+ const LDKLockableScore* operator &() const { return &self; }
+ const LDKLockableScore* operator ->() const { return &self; }
+ /**
+ * Returns read locked scorer.
+ */
+ inline LDK::ScoreLookUp read_lock();
+ /**
+ * Returns write locked scorer.
+ */
+ inline LDK::ScoreUpdate write_lock();
+};
+class WriteableScore {
+private:
+ LDKWriteableScore self;
+public:
+ WriteableScore(const WriteableScore&) = delete;
+ WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
+ WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
+ operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
+ ~WriteableScore() { WriteableScore_free(self); }
+ WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
+ LDKWriteableScore* operator &() { return &self; }
+ LDKWriteableScore* operator ->() { return &self; }
+ const LDKWriteableScore* operator &() const { return &self; }
+ const LDKWriteableScore* operator ->() const { return &self; }
+};
+class MultiThreadedLockableScore {
+private:
+ LDKMultiThreadedLockableScore self;
+public:
+ MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
+ MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
+ MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
+ operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
+ ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
+ MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
+ LDKMultiThreadedLockableScore* operator &() { return &self; }
+ LDKMultiThreadedLockableScore* operator ->() { return &self; }
+ const LDKMultiThreadedLockableScore* operator &() const { return &self; }
+ const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
+};
+class MultiThreadedScoreLockRead {
+private:
+ LDKMultiThreadedScoreLockRead self;
+public:
+ MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
+ MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
+ MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
+ operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
+ ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
+ MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
+ LDKMultiThreadedScoreLockRead* operator &() { return &self; }
+ LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
+ const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
+ const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
+};
+class MultiThreadedScoreLockWrite {
+private:
+ LDKMultiThreadedScoreLockWrite self;
+public:
+ MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
+ MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
+ MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
+ operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
+ ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
+ MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
+ LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
+ LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
+ const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
+ const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
+};
+class ChannelUsage {
+private:
+ LDKChannelUsage self;
+public:
+ ChannelUsage(const ChannelUsage&) = delete;
+ ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
+ ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
+ operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
+ ~ChannelUsage() { ChannelUsage_free(self); }
+ ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
+ LDKChannelUsage* operator &() { return &self; }
+ LDKChannelUsage* operator ->() { return &self; }
+ const LDKChannelUsage* operator &() const { return &self; }
+ const LDKChannelUsage* operator ->() const { return &self; }
+};
+class FixedPenaltyScorer {
+private:
+ LDKFixedPenaltyScorer self;
+public:
+ FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
+ FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
+ FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
+ operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
+ ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
+ FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
+ LDKFixedPenaltyScorer* operator &() { return &self; }
+ LDKFixedPenaltyScorer* operator ->() { return &self; }
+ const LDKFixedPenaltyScorer* operator &() const { return &self; }
+ const LDKFixedPenaltyScorer* operator ->() const { return &self; }
+};
+class ProbabilisticScorer {
+private:
+ LDKProbabilisticScorer self;
+public:
+ ProbabilisticScorer(const ProbabilisticScorer&) = delete;
+ ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
+ ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
+ operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
+ ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
+ ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
+ LDKProbabilisticScorer* operator &() { return &self; }
+ LDKProbabilisticScorer* operator ->() { return &self; }
+ const LDKProbabilisticScorer* operator &() const { return &self; }
+ const LDKProbabilisticScorer* operator ->() const { return &self; }
+};
+class ProbabilisticScoringFeeParameters {
+private:
+ LDKProbabilisticScoringFeeParameters self;
+public:
+ ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
+ ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
+ ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
+ operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
+ ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
+ ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
+ LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
+ LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
+ const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
+ const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
+};
+class ProbabilisticScoringDecayParameters {
+private:
+ LDKProbabilisticScoringDecayParameters self;
+public:
+ ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
+ ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
+ ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
+ operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
+ ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
+ ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
+ LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
+ LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
+ const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
+ const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
+};
+class BestBlock {
+private:
+ LDKBestBlock self;
+public:
+ BestBlock(const BestBlock&) = delete;
+ BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
+ BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
+ operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
+ ~BestBlock() { BestBlock_free(self); }
+ BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
+ LDKBestBlock* operator &() { return &self; }
+ LDKBestBlock* operator ->() { return &self; }
+ const LDKBestBlock* operator &() const { return &self; }
+ const LDKBestBlock* operator ->() const { return &self; }
+};
+class Listen {
+private:
+ LDKListen self;
+public:
+ Listen(const Listen&) = delete;
+ Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
+ Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
+ operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
+ ~Listen() { Listen_free(self); }
+ Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
+ LDKListen* operator &() { return &self; }
+ LDKListen* operator ->() { return &self; }
+ const LDKListen* operator &() const { return &self; }
+ const LDKListen* operator ->() const { return &self; }
+ /**
+ * Notifies the listener that a block was added at the given height, with the transaction data
+ * possibly filtered.
+ */
+ inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
+ /**
+ * Notifies the listener that a block was added at the given height.
+ */
+ inline void block_connected(struct LDKu8slice block, uint32_t height);
+ /**
+ * Notifies the listener that a block was removed at the given height.
+ */
+ inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
+};
+class Confirm {
+private:
+ LDKConfirm self;
+public:
+ Confirm(const Confirm&) = delete;
+ Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
+ Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
+ operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
+ ~Confirm() { Confirm_free(self); }
+ Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
+ LDKConfirm* operator &() { return &self; }
+ LDKConfirm* operator ->() { return &self; }
+ const LDKConfirm* operator &() const { return &self; }
+ const LDKConfirm* operator ->() const { return &self; }
+ /**
+ * Notifies LDK of transactions confirmed in a block with a given header and height.
+ *
+ * Must be called for any transactions registered by [`Filter::register_tx`] or any
+ * transactions spending an output registered by [`Filter::register_output`]. Such transactions
+ * appearing in the same block do not need to be included in the same call; instead, multiple
+ * calls with additional transactions may be made so long as they are made in [chain order].
+ *
+ * May be called before or after [`best_block_updated`] for the corresponding block. However,
+ * in the event of a chain reorganization, it must not be called with a `header` that is no
+ * longer in the chain as of the last call to [`best_block_updated`].
+ *
+ * [chain order]: Confirm#order
+ * [`best_block_updated`]: Self::best_block_updated
+ */
+ inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
+ /**
+ * Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
+ *
+ * Must be called for any transaction returned by [`get_relevant_txids`] if it has been
+ * reorganized out of the best chain or if it is no longer confirmed in the block with the
+ * given block hash. Once called, the given transaction will not be returned
+ * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
+ *
+ * [`get_relevant_txids`]: Self::get_relevant_txids
+ * [`transactions_confirmed`]: Self::transactions_confirmed
+ */
+ inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
+ /**
+ * Notifies LDK of an update to the best header connected at the given height.
+ *
+ * Must be called whenever a new chain tip becomes available. May be skipped for intermediary
+ * blocks.
+ */
+ inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
+ /**
+ * Returns transactions that must be monitored for reorganization out of the chain along
+ * with the height and the hash of the block as part of which it had been previously confirmed.
+ *
+ * Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
+ * 0.0.112 and prior, in which case you need to manually track previous confirmations.
+ *
+ * Will include any transactions passed to [`transactions_confirmed`] that have insufficient
+ * confirmations to be safe from a chain reorganization. Will not include any transactions
+ * passed to [`transaction_unconfirmed`], unless later reconfirmed.
+ *
+ * Must be called to determine the subset of transactions that must be monitored for
+ * reorganization. Will be idempotent between calls but may change as a result of calls to the
+ * other interface methods. Thus, this is useful to determine which transactions must be
+ * given to [`transaction_unconfirmed`].
+ *
+ * If any of the returned transactions are confirmed in a block other than the one with the
+ * given hash at the given height, they need to be unconfirmed and reconfirmed via
+ * [`transaction_unconfirmed`] and [`transactions_confirmed`], respectively.
+ *
+ * [`transactions_confirmed`]: Self::transactions_confirmed
+ * [`transaction_unconfirmed`]: Self::transaction_unconfirmed
+ */
+ inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ get_relevant_txids();
+};
+class ChannelMonitorUpdateStatus {
+private:
+ LDKChannelMonitorUpdateStatus self;
+public:
+ ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
+ ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
+ ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
+ operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
+ ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
+ LDKChannelMonitorUpdateStatus* operator &() { return &self; }
+ LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
+ const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
+ const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
+};
+class Watch {
+private:
+ LDKWatch self;
+public:
+ Watch(const Watch&) = delete;
+ Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
+ Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
+ operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
+ ~Watch() { Watch_free(self); }
+ Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
+ LDKWatch* operator &() { return &self; }
+ LDKWatch* operator ->() { return &self; }
+ const LDKWatch* operator &() const { return &self; }
+ const LDKWatch* operator ->() const { return &self; }
+ /**
+ * Watches a channel identified by `funding_txo` using `monitor`.
+ *
+ * Implementations are responsible for watching the chain for the funding transaction along
+ * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
+ * calling [`block_connected`] and [`block_disconnected`] on the monitor.
+ *
+ * A return of `Err(())` indicates that the channel should immediately be force-closed without
+ * broadcasting the funding transaction.
+ *
+ * If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
+ * must be returned.
+ *
+ * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
+ * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
+ * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
+ */
+ inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
+ /**
+ * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
+ *
+ * Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
+ * may fail (returning an `Err(())`), in which case this should return
+ * [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
+ * generally implies the channel has been closed (either by the funding outpoint being spent
+ * on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
+ * and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
+ *
+ * In general, persistence failures should be retried after returning
+ * [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
+ * cannot be retried, the node should shut down immediately after returning
+ * [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
+ *
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ */
+ inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
+ /**
+ * Returns any monitor events since the last call. Subsequent calls must only return new
+ * events.
+ *
+ * Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
+ * further events may be returned here until the [`ChannelMonitor`] has been fully persisted
+ * to disk.
+ *
+ * For details on asynchronous [`ChannelMonitor`] updating and returning
+ * [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
+ */
+ inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
+};
+class Filter {
+private:
+ LDKFilter self;
+public:
+ Filter(const Filter&) = delete;
+ Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
+ Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
+ operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
+ ~Filter() { Filter_free(self); }
+ Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
+ LDKFilter* operator &() { return &self; }
+ LDKFilter* operator ->() { return &self; }
+ const LDKFilter* operator &() const { return &self; }
+ const LDKFilter* operator ->() const { return &self; }
+ /**
+ * Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
+ * a spending condition.
+ *
+ * This may be used, for example, to monitor for when a funding transaction confirms.
+ *
+ * The `script_pubkey` is provided for informational purposes and may be useful for block
+ * sources which only support filtering on scripts.
+ */
+ inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
+ /**
+ * Registers interest in spends of a transaction output.
+ *
+ * Note that this method might be called during processing of a new block. You therefore need
+ * to ensure that also dependent output spents within an already connected block are correctly
+ * handled, e.g., by re-scanning the block in question whenever new outputs have been
+ * registered mid-processing.
+ *
+ * This may be used, for example, to monitor for when a funding output is spent (by any
+ * transaction).
+ */
+ inline void register_output(struct LDKWatchedOutput output);
+};
+class WatchedOutput {
+private:
+ LDKWatchedOutput self;
+public:
+ WatchedOutput(const WatchedOutput&) = delete;
+ WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
+ WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
+ operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
+ ~WatchedOutput() { WatchedOutput_free(self); }
+ WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
+ LDKWatchedOutput* operator &() { return &self; }
+ LDKWatchedOutput* operator ->() { return &self; }
+ const LDKWatchedOutput* operator &() const { return &self; }
+ const LDKWatchedOutput* operator ->() const { return &self; }
+};
+class OfferId {
+private:
+ LDKOfferId self;
+public:
+ OfferId(const OfferId&) = delete;
+ OfferId(OfferId&& o) : self(o.self) { memset(&o, 0, sizeof(OfferId)); }
+ OfferId(LDKOfferId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferId)); }
+ operator LDKOfferId() && { LDKOfferId res = self; memset(&self, 0, sizeof(LDKOfferId)); return res; }
+ ~OfferId() { OfferId_free(self); }
+ OfferId& operator=(OfferId&& o) { OfferId_free(self); self = o.self; memset(&o, 0, sizeof(OfferId)); return *this; }
+ LDKOfferId* operator &() { return &self; }
+ LDKOfferId* operator ->() { return &self; }
+ const LDKOfferId* operator &() const { return &self; }
+ const LDKOfferId* operator ->() const { return &self; }
+};
+class OfferWithExplicitMetadataBuilder {
+private:
+ LDKOfferWithExplicitMetadataBuilder self;
+public:
+ OfferWithExplicitMetadataBuilder(const OfferWithExplicitMetadataBuilder&) = delete;
+ OfferWithExplicitMetadataBuilder(OfferWithExplicitMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); }
+ OfferWithExplicitMetadataBuilder(LDKOfferWithExplicitMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); }
+ operator LDKOfferWithExplicitMetadataBuilder() && { LDKOfferWithExplicitMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithExplicitMetadataBuilder)); return res; }
+ ~OfferWithExplicitMetadataBuilder() { OfferWithExplicitMetadataBuilder_free(self); }
+ OfferWithExplicitMetadataBuilder& operator=(OfferWithExplicitMetadataBuilder&& o) { OfferWithExplicitMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithExplicitMetadataBuilder)); return *this; }
+ LDKOfferWithExplicitMetadataBuilder* operator &() { return &self; }
+ LDKOfferWithExplicitMetadataBuilder* operator ->() { return &self; }
+ const LDKOfferWithExplicitMetadataBuilder* operator &() const { return &self; }
+ const LDKOfferWithExplicitMetadataBuilder* operator ->() const { return &self; }
+};
+class OfferWithDerivedMetadataBuilder {
+private:
+ LDKOfferWithDerivedMetadataBuilder self;
+public:
+ OfferWithDerivedMetadataBuilder(const OfferWithDerivedMetadataBuilder&) = delete;
+ OfferWithDerivedMetadataBuilder(OfferWithDerivedMetadataBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); }
+ OfferWithDerivedMetadataBuilder(LDKOfferWithDerivedMetadataBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); }
+ operator LDKOfferWithDerivedMetadataBuilder() && { LDKOfferWithDerivedMetadataBuilder res = self; memset(&self, 0, sizeof(LDKOfferWithDerivedMetadataBuilder)); return res; }
+ ~OfferWithDerivedMetadataBuilder() { OfferWithDerivedMetadataBuilder_free(self); }
+ OfferWithDerivedMetadataBuilder& operator=(OfferWithDerivedMetadataBuilder&& o) { OfferWithDerivedMetadataBuilder_free(self); self = o.self; memset(&o, 0, sizeof(OfferWithDerivedMetadataBuilder)); return *this; }
+ LDKOfferWithDerivedMetadataBuilder* operator &() { return &self; }
+ LDKOfferWithDerivedMetadataBuilder* operator ->() { return &self; }
+ const LDKOfferWithDerivedMetadataBuilder* operator &() const { return &self; }
+ const LDKOfferWithDerivedMetadataBuilder* operator ->() const { return &self; }
+};
+class Offer {
+private:
+ LDKOffer self;
+public:
+ Offer(const Offer&) = delete;
+ Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
+ Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
+ operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
+ ~Offer() { Offer_free(self); }
+ Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
+ LDKOffer* operator &() { return &self; }
+ LDKOffer* operator ->() { return &self; }
+ const LDKOffer* operator &() const { return &self; }
+ const LDKOffer* operator ->() const { return &self; }
+};
+class Amount {
+private:
+ LDKAmount self;
+public:
+ Amount(const Amount&) = delete;
+ Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
+ Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
+ operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
+ ~Amount() { Amount_free(self); }
+ Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
+ LDKAmount* operator &() { return &self; }
+ LDKAmount* operator ->() { return &self; }
+ const LDKAmount* operator &() const { return &self; }
+ const LDKAmount* operator ->() const { return &self; }
+};
+class Quantity {
+private:
+ LDKQuantity self;
+public:
+ Quantity(const Quantity&) = delete;
+ Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
+ Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
+ operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
+ ~Quantity() { Quantity_free(self); }
+ Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
+ LDKQuantity* operator &() { return &self; }
+ LDKQuantity* operator ->() { return &self; }
+ const LDKQuantity* operator &() const { return &self; }
+ const LDKQuantity* operator ->() const { return &self; }
+};
+class NodeId {
+private:
+ LDKNodeId self;
+public:
+ NodeId(const NodeId&) = delete;
+ NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
+ NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
+ operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
+ ~NodeId() { NodeId_free(self); }
+ NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
+ LDKNodeId* operator &() { return &self; }
+ LDKNodeId* operator ->() { return &self; }
+ const LDKNodeId* operator &() const { return &self; }
+ const LDKNodeId* operator ->() const { return &self; }
+};
+class NetworkGraph {
+private:
+ LDKNetworkGraph self;
+public:
+ NetworkGraph(const NetworkGraph&) = delete;
+ NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
+ NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
+ operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
+ ~NetworkGraph() { NetworkGraph_free(self); }
+ NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
+ LDKNetworkGraph* operator &() { return &self; }
+ LDKNetworkGraph* operator ->() { return &self; }
+ const LDKNetworkGraph* operator &() const { return &self; }
+ const LDKNetworkGraph* operator ->() const { return &self; }
+};
+class ReadOnlyNetworkGraph {
+private:
+ LDKReadOnlyNetworkGraph self;
+public:
+ ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
+ ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
+ ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
+ operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
+ ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
+ ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
+ LDKReadOnlyNetworkGraph* operator &() { return &self; }
+ LDKReadOnlyNetworkGraph* operator ->() { return &self; }
+ const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
+ const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
+};
+class NetworkUpdate {
+private:
+ LDKNetworkUpdate self;
+public:
+ NetworkUpdate(const NetworkUpdate&) = delete;
+ NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
+ NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
+ operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
+ ~NetworkUpdate() { NetworkUpdate_free(self); }
+ NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
+ LDKNetworkUpdate* operator &() { return &self; }
+ LDKNetworkUpdate* operator ->() { return &self; }
+ const LDKNetworkUpdate* operator &() const { return &self; }
+ const LDKNetworkUpdate* operator ->() const { return &self; }
+};
+class P2PGossipSync {
+private:
+ LDKP2PGossipSync self;
+public:
+ P2PGossipSync(const P2PGossipSync&) = delete;
+ P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
+ P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
+ operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
+ ~P2PGossipSync() { P2PGossipSync_free(self); }
+ P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
+ LDKP2PGossipSync* operator &() { return &self; }
+ LDKP2PGossipSync* operator ->() { return &self; }
+ const LDKP2PGossipSync* operator &() const { return &self; }
+ const LDKP2PGossipSync* operator ->() const { return &self; }
+};
+class ChannelUpdateInfo {
+private:
+ LDKChannelUpdateInfo self;
+public:
+ ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
+ ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
+ ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
+ operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
+ ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
+ ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
+ LDKChannelUpdateInfo* operator &() { return &self; }
+ LDKChannelUpdateInfo* operator ->() { return &self; }
+ const LDKChannelUpdateInfo* operator &() const { return &self; }
+ const LDKChannelUpdateInfo* operator ->() const { return &self; }
+};
+class ChannelInfo {
+private:
+ LDKChannelInfo self;
+public:
+ ChannelInfo(const ChannelInfo&) = delete;
+ ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
+ ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
+ operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
+ ~ChannelInfo() { ChannelInfo_free(self); }
+ ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
+ LDKChannelInfo* operator &() { return &self; }
+ LDKChannelInfo* operator ->() { return &self; }
+ const LDKChannelInfo* operator &() const { return &self; }
+ const LDKChannelInfo* operator ->() const { return &self; }
+};
+class DirectedChannelInfo {
+private:
+ LDKDirectedChannelInfo self;
+public:
+ DirectedChannelInfo(const DirectedChannelInfo&) = delete;
+ DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
+ DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
+ operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
+ ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
+ DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
+ LDKDirectedChannelInfo* operator &() { return &self; }
+ LDKDirectedChannelInfo* operator ->() { return &self; }
+ const LDKDirectedChannelInfo* operator &() const { return &self; }
+ const LDKDirectedChannelInfo* operator ->() const { return &self; }
+};
+class EffectiveCapacity {
+private:
+ LDKEffectiveCapacity self;
+public:
+ EffectiveCapacity(const EffectiveCapacity&) = delete;
+ EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
+ EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
+ operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
+ ~EffectiveCapacity() { EffectiveCapacity_free(self); }
+ EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
+ LDKEffectiveCapacity* operator &() { return &self; }
+ LDKEffectiveCapacity* operator ->() { return &self; }
+ const LDKEffectiveCapacity* operator &() const { return &self; }
+ const LDKEffectiveCapacity* operator ->() const { return &self; }
+};
+class NodeAnnouncementDetails {
+private:
+ LDKNodeAnnouncementDetails self;
+public:
+ NodeAnnouncementDetails(const NodeAnnouncementDetails&) = delete;
+ NodeAnnouncementDetails(NodeAnnouncementDetails&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementDetails)); }
+ NodeAnnouncementDetails(LDKNodeAnnouncementDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementDetails)); }
+ operator LDKNodeAnnouncementDetails() && { LDKNodeAnnouncementDetails res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementDetails)); return res; }
+ ~NodeAnnouncementDetails() { NodeAnnouncementDetails_free(self); }
+ NodeAnnouncementDetails& operator=(NodeAnnouncementDetails&& o) { NodeAnnouncementDetails_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementDetails)); return *this; }
+ LDKNodeAnnouncementDetails* operator &() { return &self; }
+ LDKNodeAnnouncementDetails* operator ->() { return &self; }
+ const LDKNodeAnnouncementDetails* operator &() const { return &self; }
+ const LDKNodeAnnouncementDetails* operator ->() const { return &self; }
+};
+class NodeAnnouncementInfo {
+private:
+ LDKNodeAnnouncementInfo self;
+public:
+ NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
+ NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
+ NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
+ operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
+ ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
+ NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
+ LDKNodeAnnouncementInfo* operator &() { return &self; }
+ LDKNodeAnnouncementInfo* operator ->() { return &self; }
+ const LDKNodeAnnouncementInfo* operator &() const { return &self; }
+ const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
+};
+class NodeAlias {
+private:
+ LDKNodeAlias self;
+public:
+ NodeAlias(const NodeAlias&) = delete;
+ NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
+ NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
+ operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
+ ~NodeAlias() { NodeAlias_free(self); }
+ NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
+ LDKNodeAlias* operator &() { return &self; }
+ LDKNodeAlias* operator ->() { return &self; }
+ const LDKNodeAlias* operator &() const { return &self; }
+ const LDKNodeAlias* operator ->() const { return &self; }
+};
+class NodeInfo {
+private:
+ LDKNodeInfo self;
+public:
+ NodeInfo(const NodeInfo&) = delete;
+ NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
+ NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
+ operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
+ ~NodeInfo() { NodeInfo_free(self); }
+ NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
+ LDKNodeInfo* operator &() { return &self; }
+ LDKNodeInfo* operator ->() { return &self; }
+ const LDKNodeInfo* operator &() const { return &self; }
+ const LDKNodeInfo* operator ->() const { return &self; }
+};
+class ShortChannelIdError {
+private:
+ LDKShortChannelIdError self;
+public:
+ ShortChannelIdError(const ShortChannelIdError&) = delete;
+ ShortChannelIdError(ShortChannelIdError&& o) : self(o.self) { memset(&o, 0, sizeof(ShortChannelIdError)); }
+ ShortChannelIdError(LDKShortChannelIdError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShortChannelIdError)); }
+ operator LDKShortChannelIdError() && { LDKShortChannelIdError res = self; memset(&self, 0, sizeof(LDKShortChannelIdError)); return res; }
+ ShortChannelIdError& operator=(ShortChannelIdError&& o) { self = o.self; memset(&o, 0, sizeof(ShortChannelIdError)); return *this; }
+ LDKShortChannelIdError* operator &() { return &self; }
+ LDKShortChannelIdError* operator ->() { return &self; }
+ const LDKShortChannelIdError* operator &() const { return &self; }
+ const LDKShortChannelIdError* operator ->() const { return &self; }
+};
+class InboundHTLCErr {
+private:
+ LDKInboundHTLCErr self;
+public:
+ InboundHTLCErr(const InboundHTLCErr&) = delete;
+ InboundHTLCErr(InboundHTLCErr&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCErr)); }
+ InboundHTLCErr(LDKInboundHTLCErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCErr)); }
+ operator LDKInboundHTLCErr() && { LDKInboundHTLCErr res = self; memset(&self, 0, sizeof(LDKInboundHTLCErr)); return res; }
+ ~InboundHTLCErr() { InboundHTLCErr_free(self); }
+ InboundHTLCErr& operator=(InboundHTLCErr&& o) { InboundHTLCErr_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCErr)); return *this; }
+ LDKInboundHTLCErr* operator &() { return &self; }
+ LDKInboundHTLCErr* operator ->() { return &self; }
+ const LDKInboundHTLCErr* operator &() const { return &self; }
+ const LDKInboundHTLCErr* operator ->() const { return &self; }
+};
+class AnchorDescriptor {
+private:
+ LDKAnchorDescriptor self;
+public:
+ AnchorDescriptor(const AnchorDescriptor&) = delete;
+ AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
+ AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
+ operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
+ ~AnchorDescriptor() { AnchorDescriptor_free(self); }
+ AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
+ LDKAnchorDescriptor* operator &() { return &self; }
+ LDKAnchorDescriptor* operator ->() { return &self; }
+ const LDKAnchorDescriptor* operator &() const { return &self; }
+ const LDKAnchorDescriptor* operator ->() const { return &self; }
+};
+class BumpTransactionEvent {
+private:
+ LDKBumpTransactionEvent self;
+public:
+ BumpTransactionEvent(const BumpTransactionEvent&) = delete;
+ BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
+ BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
+ operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
+ ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
+ BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
+ LDKBumpTransactionEvent* operator &() { return &self; }
+ LDKBumpTransactionEvent* operator ->() { return &self; }
+ const LDKBumpTransactionEvent* operator &() const { return &self; }
+ const LDKBumpTransactionEvent* operator ->() const { return &self; }
+};
+class Input {
+private:
+ LDKInput self;
+public:
+ Input(const Input&) = delete;
+ Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
+ Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
+ operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
+ ~Input() { Input_free(self); }
+ Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
+ LDKInput* operator &() { return &self; }
+ LDKInput* operator ->() { return &self; }
+ const LDKInput* operator &() const { return &self; }
+ const LDKInput* operator ->() const { return &self; }
+};
+class Utxo {
+private:
+ LDKUtxo self;
+public:
+ Utxo(const Utxo&) = delete;
+ Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
+ Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
+ operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
+ ~Utxo() { Utxo_free(self); }
+ Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
+ LDKUtxo* operator &() { return &self; }
+ LDKUtxo* operator ->() { return &self; }
+ const LDKUtxo* operator &() const { return &self; }
+ const LDKUtxo* operator ->() const { return &self; }
+};
+class CoinSelection {
+private:
+ LDKCoinSelection self;
+public:
+ CoinSelection(const CoinSelection&) = delete;
+ CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
+ CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
+ operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
+ ~CoinSelection() { CoinSelection_free(self); }
+ CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
+ LDKCoinSelection* operator &() { return &self; }
+ LDKCoinSelection* operator ->() { return &self; }
+ const LDKCoinSelection* operator &() const { return &self; }
+ const LDKCoinSelection* operator ->() const { return &self; }
+};
+class CoinSelectionSource {
+private:
+ LDKCoinSelectionSource self;
+public:
+ CoinSelectionSource(const CoinSelectionSource&) = delete;
+ CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
+ CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
+ operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
+ ~CoinSelectionSource() { CoinSelectionSource_free(self); }
+ CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
+ LDKCoinSelectionSource* operator &() { return &self; }
+ LDKCoinSelectionSource* operator ->() { return &self; }
+ const LDKCoinSelectionSource* operator &() const { return &self; }
+ const LDKCoinSelectionSource* operator ->() const { return &self; }
+ /**
+ * Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
+ * available to spend. Implementations are free to pick their coin selection algorithm of
+ * choice, as long as the following requirements are met:
+ *
+ * 1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
+ * throughout coin selection, but must not be returned as part of the result.
+ * 2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
+ * throughout coin selection. In some cases, like when funding an anchor transaction, this
+ * set is empty. Implementations should ensure they handle this correctly on their end,
+ * e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
+ * provided, in which case a zero-value empty OP_RETURN output can be used instead.
+ * 3. Enough inputs must be selected/contributed for the resulting transaction (including the
+ * inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
+ *
+ * Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
+ * the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
+ * providing the full input weight. Failing to do so may lead to underestimating fee bumps and
+ * delaying block inclusion.
+ *
+ * The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
+ * can be re-used within new fee-bumped iterations of the original claiming transaction,
+ * ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
+ * transaction associated with it, and all of the available UTXOs have already been assigned to
+ * other claims, implementations must be willing to double spend their UTXOs. The choice of
+ * which UTXOs to double spend is left to the implementation, but it must strive to keep the
+ * set of other claims being double spent to a minimum.
+ */
+ inline LDK::CResult_CoinSelectionNoneZ select_confirmed_utxos(struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight);
+ /**
+ * Signs and provides the full witness for all inputs within the transaction known to the
+ * trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
+ *
+ * If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+ * unsigned transaction and then sign it with your wallet.
+ */
+ inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
+};
+class WalletSource {
+private:
+ LDKWalletSource self;
+public:
+ WalletSource(const WalletSource&) = delete;
+ WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
+ WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
+ operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
+ ~WalletSource() { WalletSource_free(self); }
+ WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
+ LDKWalletSource* operator &() { return &self; }
+ LDKWalletSource* operator ->() { return &self; }
+ const LDKWalletSource* operator &() const { return &self; }
+ const LDKWalletSource* operator ->() const { return &self; }
+ /**
+ * Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
+ */
+ inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
+ /**
+ * Returns a script to use for change above dust resulting from a successful coin selection
+ * attempt.
+ */
+ inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
+ /**
+ * Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
+ * the transaction known to the wallet (i.e., any provided via
+ * [`WalletSource::list_confirmed_utxos`]).
+ *
+ * If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
+ * unsigned transaction and then sign it with your wallet.
+ */
+ inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
+};
+class Wallet {
+private:
+ LDKWallet self;
+public:
+ Wallet(const Wallet&) = delete;
+ Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
+ Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
+ operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
+ ~Wallet() { Wallet_free(self); }
+ Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
+ LDKWallet* operator &() { return &self; }
+ LDKWallet* operator ->() { return &self; }
+ const LDKWallet* operator &() const { return &self; }
+ const LDKWallet* operator ->() const { return &self; }
+};
+class BumpTransactionEventHandler {
+private:
+ LDKBumpTransactionEventHandler self;
+public:
+ BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
+ BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
+ BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
+ operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
+ ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
+ BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
+ LDKBumpTransactionEventHandler* operator &() { return &self; }
+ LDKBumpTransactionEventHandler* operator ->() { return &self; }
+ const LDKBumpTransactionEventHandler* operator &() const { return &self; }
+ const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
+};
+class PendingHTLCRouting {
+private:
+ LDKPendingHTLCRouting self;
+public:
+ PendingHTLCRouting(const PendingHTLCRouting&) = delete;
+ PendingHTLCRouting(PendingHTLCRouting&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCRouting)); }
+ PendingHTLCRouting(LDKPendingHTLCRouting&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCRouting)); }
+ operator LDKPendingHTLCRouting() && { LDKPendingHTLCRouting res = self; memset(&self, 0, sizeof(LDKPendingHTLCRouting)); return res; }
+ ~PendingHTLCRouting() { PendingHTLCRouting_free(self); }
+ PendingHTLCRouting& operator=(PendingHTLCRouting&& o) { PendingHTLCRouting_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCRouting)); return *this; }
+ LDKPendingHTLCRouting* operator &() { return &self; }
+ LDKPendingHTLCRouting* operator ->() { return &self; }
+ const LDKPendingHTLCRouting* operator &() const { return &self; }
+ const LDKPendingHTLCRouting* operator ->() const { return &self; }
+};
+class BlindedForward {
+private:
+ LDKBlindedForward self;
+public:
+ BlindedForward(const BlindedForward&) = delete;
+ BlindedForward(BlindedForward&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedForward)); }
+ BlindedForward(LDKBlindedForward&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedForward)); }
+ operator LDKBlindedForward() && { LDKBlindedForward res = self; memset(&self, 0, sizeof(LDKBlindedForward)); return res; }
+ ~BlindedForward() { BlindedForward_free(self); }
+ BlindedForward& operator=(BlindedForward&& o) { BlindedForward_free(self); self = o.self; memset(&o, 0, sizeof(BlindedForward)); return *this; }
+ LDKBlindedForward* operator &() { return &self; }
+ LDKBlindedForward* operator ->() { return &self; }
+ const LDKBlindedForward* operator &() const { return &self; }
+ const LDKBlindedForward* operator ->() const { return &self; }
+};
+class PendingHTLCInfo {
+private:
+ LDKPendingHTLCInfo self;
+public:
+ PendingHTLCInfo(const PendingHTLCInfo&) = delete;
+ PendingHTLCInfo(PendingHTLCInfo&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCInfo)); }
+ PendingHTLCInfo(LDKPendingHTLCInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCInfo)); }
+ operator LDKPendingHTLCInfo() && { LDKPendingHTLCInfo res = self; memset(&self, 0, sizeof(LDKPendingHTLCInfo)); return res; }
+ ~PendingHTLCInfo() { PendingHTLCInfo_free(self); }
+ PendingHTLCInfo& operator=(PendingHTLCInfo&& o) { PendingHTLCInfo_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCInfo)); return *this; }
+ LDKPendingHTLCInfo* operator &() { return &self; }
+ LDKPendingHTLCInfo* operator ->() { return &self; }
+ const LDKPendingHTLCInfo* operator &() const { return &self; }
+ const LDKPendingHTLCInfo* operator ->() const { return &self; }
+};
+class BlindedFailure {
+private:
+ LDKBlindedFailure self;
+public:
+ BlindedFailure(const BlindedFailure&) = delete;
+ BlindedFailure(BlindedFailure&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedFailure)); }
+ BlindedFailure(LDKBlindedFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedFailure)); }
+ operator LDKBlindedFailure() && { LDKBlindedFailure res = self; memset(&self, 0, sizeof(LDKBlindedFailure)); return res; }
+ BlindedFailure& operator=(BlindedFailure&& o) { self = o.self; memset(&o, 0, sizeof(BlindedFailure)); return *this; }
+ LDKBlindedFailure* operator &() { return &self; }
+ LDKBlindedFailure* operator ->() { return &self; }
+ const LDKBlindedFailure* operator &() const { return &self; }
+ const LDKBlindedFailure* operator ->() const { return &self; }
+};
+class FailureCode {
+private:
+ LDKFailureCode self;
+public:
+ FailureCode(const FailureCode&) = delete;
+ FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
+ FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
+ operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
+ ~FailureCode() { FailureCode_free(self); }
+ FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
+ LDKFailureCode* operator &() { return &self; }
+ LDKFailureCode* operator ->() { return &self; }
+ const LDKFailureCode* operator &() const { return &self; }
+ const LDKFailureCode* operator ->() const { return &self; }
+};
+class ChannelManager {
+private:
+ LDKChannelManager self;
+public:
+ ChannelManager(const ChannelManager&) = delete;
+ ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
+ ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
+ operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
+ ~ChannelManager() { ChannelManager_free(self); }
+ ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
+ LDKChannelManager* operator &() { return &self; }
+ LDKChannelManager* operator ->() { return &self; }
+ const LDKChannelManager* operator &() const { return &self; }
+ const LDKChannelManager* operator ->() const { return &self; }
+};
+class ChainParameters {
+private:
+ LDKChainParameters self;
+public:
+ ChainParameters(const ChainParameters&) = delete;
+ ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
+ ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
+ operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
+ ~ChainParameters() { ChainParameters_free(self); }
+ ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
+ LDKChainParameters* operator &() { return &self; }
+ LDKChainParameters* operator ->() { return &self; }
+ const LDKChainParameters* operator &() const { return &self; }
+ const LDKChainParameters* operator ->() const { return &self; }
+};
+class RecentPaymentDetails {
+private:
+ LDKRecentPaymentDetails self;
+public:
+ RecentPaymentDetails(const RecentPaymentDetails&) = delete;
+ RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
+ RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
+ operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
+ ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
+ RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
+ LDKRecentPaymentDetails* operator &() { return &self; }
+ LDKRecentPaymentDetails* operator ->() { return &self; }
+ const LDKRecentPaymentDetails* operator &() const { return &self; }
+ const LDKRecentPaymentDetails* operator ->() const { return &self; }
+};
+class PhantomRouteHints {
+private:
+ LDKPhantomRouteHints self;
+public:
+ PhantomRouteHints(const PhantomRouteHints&) = delete;
+ PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
+ PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
+ operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
+ ~PhantomRouteHints() { PhantomRouteHints_free(self); }
+ PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
+ LDKPhantomRouteHints* operator &() { return &self; }
+ LDKPhantomRouteHints* operator ->() { return &self; }
+ const LDKPhantomRouteHints* operator &() const { return &self; }
+ const LDKPhantomRouteHints* operator ->() const { return &self; }
+};
+class ChannelManagerReadArgs {
+private:
+ LDKChannelManagerReadArgs self;
+public:
+ ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
+ ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
+ ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
+ operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
+ ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
+ ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
+ LDKChannelManagerReadArgs* operator &() { return &self; }
+ LDKChannelManagerReadArgs* operator ->() { return &self; }
+ const LDKChannelManagerReadArgs* operator &() const { return &self; }
+ const LDKChannelManagerReadArgs* operator ->() const { return &self; }
+};
+class ChannelHandshakeConfig {
+private:
+ LDKChannelHandshakeConfig self;
+public:
+ ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
+ ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
+ ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
+ operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
+ ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
+ ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
+ LDKChannelHandshakeConfig* operator &() { return &self; }
+ LDKChannelHandshakeConfig* operator ->() { return &self; }
+ const LDKChannelHandshakeConfig* operator &() const { return &self; }
+ const LDKChannelHandshakeConfig* operator ->() const { return &self; }
+};
+class ChannelHandshakeLimits {
+private:
+ LDKChannelHandshakeLimits self;
+public:
+ ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
+ ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
+ ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
+ operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
+ ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
+ ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
+ LDKChannelHandshakeLimits* operator &() { return &self; }
+ LDKChannelHandshakeLimits* operator ->() { return &self; }
+ const LDKChannelHandshakeLimits* operator &() const { return &self; }
+ const LDKChannelHandshakeLimits* operator ->() const { return &self; }
+};
+class MaxDustHTLCExposure {
+private:
+ LDKMaxDustHTLCExposure self;
+public:
+ MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
+ MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
+ MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
+ operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
+ ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
+ MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
+ LDKMaxDustHTLCExposure* operator &() { return &self; }
+ LDKMaxDustHTLCExposure* operator ->() { return &self; }
+ const LDKMaxDustHTLCExposure* operator &() const { return &self; }
+ const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
+};
+class ChannelConfig {
+private:
+ LDKChannelConfig self;
+public:
+ ChannelConfig(const ChannelConfig&) = delete;
+ ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
+ ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
+ operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
+ ~ChannelConfig() { ChannelConfig_free(self); }
+ ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
+ LDKChannelConfig* operator &() { return &self; }
+ LDKChannelConfig* operator ->() { return &self; }
+ const LDKChannelConfig* operator &() const { return &self; }
+ const LDKChannelConfig* operator ->() const { return &self; }
+};
+class ChannelConfigUpdate {
+private:
+ LDKChannelConfigUpdate self;
+public:
+ ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
+ ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
+ ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
+ operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
+ ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
+ ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
+ LDKChannelConfigUpdate* operator &() { return &self; }
+ LDKChannelConfigUpdate* operator ->() { return &self; }
+ const LDKChannelConfigUpdate* operator &() const { return &self; }
+ const LDKChannelConfigUpdate* operator ->() const { return &self; }
+};
+class UserConfig {
+private:
+ LDKUserConfig self;
+public:
+ UserConfig(const UserConfig&) = delete;
+ UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
+ UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
+ operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
+ ~UserConfig() { UserConfig_free(self); }
+ UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
+ LDKUserConfig* operator &() { return &self; }
+ LDKUserConfig* operator ->() { return &self; }
+ const LDKUserConfig* operator &() const { return &self; }
+ const LDKUserConfig* operator ->() const { return &self; }
+};
+class APIError {
+private:
+ LDKAPIError self;
+public:
+ APIError(const APIError&) = delete;
+ APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
+ APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
+ operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
+ ~APIError() { APIError_free(self); }
+ APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
+ LDKAPIError* operator &() { return &self; }
+ LDKAPIError* operator ->() { return &self; }
+ const LDKAPIError* operator &() const { return &self; }
+ const LDKAPIError* operator ->() const { return &self; }
+};
+class TaggedHash {
+private:
+ LDKTaggedHash self;
+public:
+ TaggedHash(const TaggedHash&) = delete;
+ TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
+ TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
+ operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
+ ~TaggedHash() { TaggedHash_free(self); }
+ TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
+ LDKTaggedHash* operator &() { return &self; }
+ LDKTaggedHash* operator ->() { return &self; }
+ const LDKTaggedHash* operator &() const { return &self; }
+ const LDKTaggedHash* operator ->() const { return &self; }
+};
+class SignError {
+private:
+ LDKSignError self;
+public:
+ SignError(const SignError&) = delete;
+ SignError(SignError&& o) : self(o.self) { memset(&o, 0, sizeof(SignError)); }
+ SignError(LDKSignError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignError)); }
+ operator LDKSignError() && { LDKSignError res = self; memset(&self, 0, sizeof(LDKSignError)); return res; }
+ ~SignError() { SignError_free(self); }
+ SignError& operator=(SignError&& o) { SignError_free(self); self = o.self; memset(&o, 0, sizeof(SignError)); return *this; }
+ LDKSignError* operator &() { return &self; }
+ LDKSignError* operator ->() { return &self; }
+ const LDKSignError* operator &() const { return &self; }
+ const LDKSignError* operator ->() const { return &self; }
+};
+class EcdsaChannelSigner {
+private:
+ LDKEcdsaChannelSigner self;
+public:
+ EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
+ EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
+ EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
+ operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
+ ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
+ EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
+ LDKEcdsaChannelSigner* operator &() { return &self; }
+ LDKEcdsaChannelSigner* operator ->() { return &self; }
+ const LDKEcdsaChannelSigner* operator &() const { return &self; }
+ const LDKEcdsaChannelSigner* operator ->() const { return &self; }
+ /**
+ * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
+ *
+ * Note that if signing fails or is rejected, the channel will be force-closed.
+ *
+ * Policy checks should be implemented in this function, including checking the amount
+ * sent to us and checking the HTLCs.
+ *
+ * The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
+ * are provided. A validating signer should ensure that an outbound HTLC output is removed
+ * only when the matching preimage is provided and after the corresponding inbound HTLC has
+ * been removed for forwarded payments.
+ *
+ * Note that all the relevant preimages will be provided, but there may also be additional
+ * irrelevant or duplicate preimages.
+ */
+ inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
+ /**
+ * Creates a signature for a holder's commitment transaction.
+ *
+ * This will be called
+ * - with a non-revoked `commitment_tx`.
+ * - with the latest `commitment_tx` when we initiate a force-close.
+ *
+ * This may be called multiple times for the same transaction.
+ *
+ * An external signer implementation should check that the commitment has not been revoked.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
+ /**
+ * Create a signature for the given input in a transaction spending an HTLC transaction output
+ * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
+ *
+ * A justice transaction may claim multiple outputs at the same time if timelocks are
+ * similar, but only a signature for the input at index `input` should be signed for here.
+ * It may be called multiple times for same output(s) if a fee-bump is needed with regards
+ * to an upcoming timelock expiration.
+ *
+ * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+ *
+ * `per_commitment_key` is revocation secret which was provided by our counterparty when they
+ * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+ * not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
+ * so).
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
+ /**
+ * Create a signature for the given input in a transaction spending a commitment transaction
+ * HTLC output when our counterparty broadcasts an old state.
+ *
+ * A justice transaction may claim multiple outputs at the same time if timelocks are
+ * similar, but only a signature for the input at index `input` should be signed for here.
+ * It may be called multiple times for same output(s) if a fee-bump is needed with regards
+ * to an upcoming timelock expiration.
+ *
+ * `amount` is the value of the output spent by this input, committed to in the BIP 143
+ * signature.
+ *
+ * `per_commitment_key` is revocation secret which was provided by our counterparty when they
+ * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
+ * not allow the spending of any funds by itself (you need our holder revocation_secret to do
+ * so).
+ *
+ * `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
+ * (which is committed to in the BIP 143 signatures).
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
+ /**
+ * Computes the signature for a commitment transaction's HTLC output used as an input within
+ * `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
+ * must be be computed using [`EcdsaSighashType::All`].
+ *
+ * Note that this may be called for HTLCs in the penultimate commitment transaction if a
+ * [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
+ * broadcasts it before receiving the update for the latest commitment transaction.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
+ * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
+ /**
+ * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
+ * transaction, either offered or received.
+ *
+ * Such a transaction may claim multiples offered outputs at same time if we know the
+ * preimage for each when we create it, but only the input at index `input` should be
+ * signed for here. It may be called multiple times for same output(s) if a fee-bump is
+ * needed with regards to an upcoming timelock expiration.
+ *
+ * `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
+ * outputs.
+ *
+ * `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
+ *
+ * `per_commitment_point` is the dynamic point corresponding to the channel state
+ * detected onchain. It has been generated by our counterparty and is used to derive
+ * channel state keys, which are then included in the witness script and committed to in the
+ * BIP 143 signature.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
+ /**
+ * Create a signature for a (proposed) closing transaction.
+ *
+ * Note that, due to rounding, there may be one "missing" satoshi, and either party may have
+ * chosen to forgo their output as dust.
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
+ /**
+ * Computes the signature for a commitment transaction's anchor output used as an
+ * input within `anchor_tx`, which spends the commitment transaction, at index `input`.
+ *
+ * An `Err` can be returned to signal that the signer is unavailable/cannot produce a valid
+ * signature and should be retried later. Once the signer is ready to provide a signature after
+ * previously returning an `Err`, [`ChannelMonitor::signer_unblocked`] must be called on its
+ * monitor.
+ *
+ * [`ChannelMonitor::signer_unblocked`]: crate::chain::channelmonitor::ChannelMonitor::signer_unblocked
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
+ /**
+ * Signs a channel announcement message with our funding key proving it comes from one of the
+ * channel participants.
+ *
+ * Channel announcements also require a signature from each node's network key. Our node
+ * signature is computed through [`NodeSigner::sign_gossip_message`].
+ *
+ * Note that if this fails or is rejected, the channel will not be publicly announced and
+ * our counterparty may (though likely will not) close the channel on us for violating the
+ * protocol.
+ *
+ * [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
+ */
+ inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+};
+class ChannelMonitorUpdate {
+private:
+ LDKChannelMonitorUpdate self;
+public:
+ ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
+ ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
+ ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
+ operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
+ ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
+ ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
+ LDKChannelMonitorUpdate* operator &() { return &self; }
+ LDKChannelMonitorUpdate* operator ->() { return &self; }
+ const LDKChannelMonitorUpdate* operator &() const { return &self; }
+ const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+};
+class MonitorEvent {
+private:
+ LDKMonitorEvent self;
+public:
+ MonitorEvent(const MonitorEvent&) = delete;
+ MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
+ MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
+ operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
+ ~MonitorEvent() { MonitorEvent_free(self); }
+ MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
+ LDKMonitorEvent* operator &() { return &self; }
+ LDKMonitorEvent* operator ->() { return &self; }
+ const LDKMonitorEvent* operator &() const { return &self; }
+ const LDKMonitorEvent* operator ->() const { return &self; }
+};
+class HTLCUpdate {
+private:
+ LDKHTLCUpdate self;
+public:
+ HTLCUpdate(const HTLCUpdate&) = delete;
+ HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
+ HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
+ operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
+ ~HTLCUpdate() { HTLCUpdate_free(self); }
+ HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
+ LDKHTLCUpdate* operator &() { return &self; }
+ LDKHTLCUpdate* operator ->() { return &self; }
+ const LDKHTLCUpdate* operator &() const { return &self; }
+ const LDKHTLCUpdate* operator ->() const { return &self; }
+};
+class BalanceSource {
+private:
+ LDKBalanceSource self;
+public:
+ BalanceSource(const BalanceSource&) = delete;
+ BalanceSource(BalanceSource&& o) : self(o.self) { memset(&o, 0, sizeof(BalanceSource)); }
+ BalanceSource(LDKBalanceSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalanceSource)); }
+ operator LDKBalanceSource() && { LDKBalanceSource res = self; memset(&self, 0, sizeof(LDKBalanceSource)); return res; }
+ BalanceSource& operator=(BalanceSource&& o) { self = o.self; memset(&o, 0, sizeof(BalanceSource)); return *this; }
+ LDKBalanceSource* operator &() { return &self; }
+ LDKBalanceSource* operator ->() { return &self; }
+ const LDKBalanceSource* operator &() const { return &self; }
+ const LDKBalanceSource* operator ->() const { return &self; }
+};
+class Balance {
+private:
+ LDKBalance self;
+public:
+ Balance(const Balance&) = delete;
+ Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
+ Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
+ operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
+ ~Balance() { Balance_free(self); }
+ Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
+ LDKBalance* operator &() { return &self; }
+ LDKBalance* operator ->() { return &self; }
+ const LDKBalance* operator &() const { return &self; }
+ const LDKBalance* operator ->() const { return &self; }
+};
+class ChannelMonitor {
+private:
+ LDKChannelMonitor self;
+public:
+ ChannelMonitor(const ChannelMonitor&) = delete;
+ ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
+ ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
+ operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
+ ~ChannelMonitor() { ChannelMonitor_free(self); }
+ ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
+ LDKChannelMonitor* operator &() { return &self; }
+ LDKChannelMonitor* operator ->() { return &self; }
+ const LDKChannelMonitor* operator &() const { return &self; }
+ const LDKChannelMonitor* operator ->() const { return &self; }
+};
+class ExpandedKey {
+private:
+ LDKExpandedKey self;
+public:
+ ExpandedKey(const ExpandedKey&) = delete;
+ ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
+ ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
+ operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
+ ~ExpandedKey() { ExpandedKey_free(self); }
+ ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
+ LDKExpandedKey* operator &() { return &self; }
+ LDKExpandedKey* operator ->() { return &self; }
+ const LDKExpandedKey* operator &() const { return &self; }
+ const LDKExpandedKey* operator ->() const { return &self; }
+};
+class CustomMessageHandler {
+private:
+ LDKCustomMessageHandler self;
+public:
+ CustomMessageHandler(const CustomMessageHandler&) = delete;
+ CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
+ CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
+ operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
+ ~CustomMessageHandler() { CustomMessageHandler_free(self); }
+ CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
+ LDKCustomMessageHandler* operator &() { return &self; }
+ LDKCustomMessageHandler* operator ->() { return &self; }
+ const LDKCustomMessageHandler* operator &() const { return &self; }
+ const LDKCustomMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handles the given message sent from `sender_node_id`, possibly producing messages for
+ * [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
+ * to send.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
+ /**
+ * Returns the list of pending messages that were generated by the handler, clearing the list
+ * in the process. Each message is paired with the node id of the intended recipient. If no
+ * connection to the node exists, then the message is simply not sent.
+ */
+ inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
+ /**
+ * Indicates a peer disconnected.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Handle a peer connecting.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ *
+ * [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * [`Init`]: crate::ln::msgs::Init
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class IgnoringMessageHandler {
+private:
+ LDKIgnoringMessageHandler self;
+public:
+ IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
+ IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
+ IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
+ operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
+ ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
+ IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
+ LDKIgnoringMessageHandler* operator &() { return &self; }
+ LDKIgnoringMessageHandler* operator ->() { return &self; }
+ const LDKIgnoringMessageHandler* operator &() const { return &self; }
+ const LDKIgnoringMessageHandler* operator ->() const { return &self; }
+};
+class ErroringMessageHandler {
+private:
+ LDKErroringMessageHandler self;
+public:
+ ErroringMessageHandler(const ErroringMessageHandler&) = delete;
+ ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
+ ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
+ operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
+ ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
+ ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
+ LDKErroringMessageHandler* operator &() { return &self; }
+ LDKErroringMessageHandler* operator ->() { return &self; }
+ const LDKErroringMessageHandler* operator &() const { return &self; }
+ const LDKErroringMessageHandler* operator ->() const { return &self; }
+};
+class MessageHandler {
+private:
+ LDKMessageHandler self;
+public:
+ MessageHandler(const MessageHandler&) = delete;
+ MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
+ MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
+ operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
+ ~MessageHandler() { MessageHandler_free(self); }
+ MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
+ LDKMessageHandler* operator &() { return &self; }
+ LDKMessageHandler* operator ->() { return &self; }
+ const LDKMessageHandler* operator &() const { return &self; }
+ const LDKMessageHandler* operator ->() const { return &self; }
+};
+class SocketDescriptor {
+private:
+ LDKSocketDescriptor self;
+public:
+ SocketDescriptor(const SocketDescriptor&) = delete;
+ SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
+ SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
+ operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
+ ~SocketDescriptor() { SocketDescriptor_free(self); }
+ SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
+ LDKSocketDescriptor* operator &() { return &self; }
+ LDKSocketDescriptor* operator ->() { return &self; }
+ const LDKSocketDescriptor* operator &() const { return &self; }
+ const LDKSocketDescriptor* operator ->() const { return &self; }
+ /**
+ * Attempts to send some data from the given slice to the peer.
+ *
+ * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
+ * Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
+ * called and further write attempts may occur until that time.
+ *
+ * If the returned size is smaller than `data.len()`, a
+ * [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
+ * written. Additionally, until a `send_data` event completes fully, no further
+ * [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
+ * prevent denial-of-service issues, you should not read or buffer any data from the socket
+ * until then.
+ *
+ * If a [`PeerManager::read_event`] call on this descriptor had previously returned true
+ * (indicating that read events should be paused to prevent DoS in the send buffer),
+ * `resume_read` may be set indicating that read events on this descriptor should resume. A
+ * `resume_read` of false carries no meaning, and should not cause any action.
+ */
+ inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
+ /**
+ * Disconnect the socket pointed to by this SocketDescriptor.
+ *
+ * You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
+ * call (doing so is a noop).
+ */
+ inline void disconnect_socket();
+ /** Checks if two objects are equal given this object's this_arg pointer and another object. */
+ inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
+ /**
+ * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
+ * This is used, for example, for inclusion of this object in a hash map.
+ */
+ inline uint64_t hash();
+};
+class PeerDetails {
+private:
+ LDKPeerDetails self;
+public:
+ PeerDetails(const PeerDetails&) = delete;
+ PeerDetails(PeerDetails&& o) : self(o.self) { memset(&o, 0, sizeof(PeerDetails)); }
+ PeerDetails(LDKPeerDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerDetails)); }
+ operator LDKPeerDetails() && { LDKPeerDetails res = self; memset(&self, 0, sizeof(LDKPeerDetails)); return res; }
+ ~PeerDetails() { PeerDetails_free(self); }
+ PeerDetails& operator=(PeerDetails&& o) { PeerDetails_free(self); self = o.self; memset(&o, 0, sizeof(PeerDetails)); return *this; }
+ LDKPeerDetails* operator &() { return &self; }
+ LDKPeerDetails* operator ->() { return &self; }
+ const LDKPeerDetails* operator &() const { return &self; }
+ const LDKPeerDetails* operator ->() const { return &self; }
+};
+class PeerHandleError {
+private:
+ LDKPeerHandleError self;
+public:
+ PeerHandleError(const PeerHandleError&) = delete;
+ PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
+ PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
+ operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
+ ~PeerHandleError() { PeerHandleError_free(self); }
+ PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
+ LDKPeerHandleError* operator &() { return &self; }
+ LDKPeerHandleError* operator ->() { return &self; }
+ const LDKPeerHandleError* operator &() const { return &self; }
+ const LDKPeerHandleError* operator ->() const { return &self; }
+};
+class PeerManager {
+private:
+ LDKPeerManager self;
+public:
+ PeerManager(const PeerManager&) = delete;
+ PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
+ PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
+ operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
+ ~PeerManager() { PeerManager_free(self); }
+ PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
+ LDKPeerManager* operator &() { return &self; }
+ LDKPeerManager* operator ->() { return &self; }
+ const LDKPeerManager* operator &() const { return &self; }
+ const LDKPeerManager* operator ->() const { return &self; }
+};
+class GraphSyncError {
+private:
+ LDKGraphSyncError self;
+public:
+ GraphSyncError(const GraphSyncError&) = delete;
+ GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
+ GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
+ operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
+ ~GraphSyncError() { GraphSyncError_free(self); }
+ GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
+ LDKGraphSyncError* operator &() { return &self; }
+ LDKGraphSyncError* operator ->() { return &self; }
+ const LDKGraphSyncError* operator &() const { return &self; }
+ const LDKGraphSyncError* operator ->() const { return &self; }
+};
+class RapidGossipSync {
+private:
+ LDKRapidGossipSync self;
+public:
+ RapidGossipSync(const RapidGossipSync&) = delete;
+ RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
+ RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
+ operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
+ ~RapidGossipSync() { RapidGossipSync_free(self); }
+ RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
+ LDKRapidGossipSync* operator &() { return &self; }
+ LDKRapidGossipSync* operator ->() { return &self; }
+ const LDKRapidGossipSync* operator &() const { return &self; }
+ const LDKRapidGossipSync* operator ->() const { return &self; }
+};
+class KVStore {
+private:
+ LDKKVStore self;
+public:
+ KVStore(const KVStore&) = delete;
+ KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
+ KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
+ operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
+ ~KVStore() { KVStore_free(self); }
+ KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
+ LDKKVStore* operator &() { return &self; }
+ LDKKVStore* operator ->() { return &self; }
+ const LDKKVStore* operator &() const { return &self; }
+ const LDKKVStore* operator ->() const { return &self; }
+ /**
+ * Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
+ * `key`.
+ *
+ * Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
+ * `primary_namespace` and `secondary_namespace`.
+ *
+ * [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
+ */
+ inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
+ /**
+ * Persists the given data under the given `key`.
+ *
+ * Will create the given `primary_namespace` and `secondary_namespace` if not already present
+ * in the store.
+ */
+ inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
+ /**
+ * Removes any data that had previously been persisted under the given `key`.
+ *
+ * If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
+ * remove the given `key` at some point in time after the method returns, e.g., as part of an
+ * eventual batch deletion of multiple keys. As a consequence, subsequent calls to
+ * [`KVStore::list`] might include the removed key until the changes are actually persisted.
+ *
+ * Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
+ * `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
+ * potentially get lost on crash after the method returns. Therefore, this flag should only be
+ * set for `remove` operations that can be safely replayed at a later time.
+ *
+ * Returns successfully if no data will be stored for the given `primary_namespace`,
+ * `secondary_namespace`, and `key`, independently of whether it was present before its
+ * invokation or not.
+ */
+ inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
+ /**
+ * Returns a list of keys that are stored under the given `secondary_namespace` in
+ * `primary_namespace`.
+ *
+ * Returns the keys in arbitrary order, so users requiring a particular order need to sort the
+ * returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
+ */
+ inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
+};
+class Persister {
+private:
+ LDKPersister self;
+public:
+ Persister(const Persister&) = delete;
+ Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
+ Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
+ operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
+ ~Persister() { Persister_free(self); }
+ Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
+ LDKPersister* operator &() { return &self; }
+ LDKPersister* operator ->() { return &self; }
+ const LDKPersister* operator &() const { return &self; }
+ const LDKPersister* operator ->() const { return &self; }
+ /**
+ * Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
+ *
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ */
+ inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
+ /**
+ * Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
+ */
+ inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
+ /**
+ * Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
+ */
+ inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
+};
+class MonitorUpdatingPersister {
+private:
+ LDKMonitorUpdatingPersister self;
+public:
+ MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
+ MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
+ MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
+ operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
+ ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
+ MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
+ LDKMonitorUpdatingPersister* operator &() { return &self; }
+ LDKMonitorUpdatingPersister* operator ->() { return &self; }
+ const LDKMonitorUpdatingPersister* operator &() const { return &self; }
+ const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
+};
+class InvoiceRequestWithExplicitPayerIdBuilder {
+private:
+ LDKInvoiceRequestWithExplicitPayerIdBuilder self;
+public:
+ InvoiceRequestWithExplicitPayerIdBuilder(const InvoiceRequestWithExplicitPayerIdBuilder&) = delete;
+ InvoiceRequestWithExplicitPayerIdBuilder(InvoiceRequestWithExplicitPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); }
+ InvoiceRequestWithExplicitPayerIdBuilder(LDKInvoiceRequestWithExplicitPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); }
+ operator LDKInvoiceRequestWithExplicitPayerIdBuilder() && { LDKInvoiceRequestWithExplicitPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithExplicitPayerIdBuilder)); return res; }
+ ~InvoiceRequestWithExplicitPayerIdBuilder() { InvoiceRequestWithExplicitPayerIdBuilder_free(self); }
+ InvoiceRequestWithExplicitPayerIdBuilder& operator=(InvoiceRequestWithExplicitPayerIdBuilder&& o) { InvoiceRequestWithExplicitPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithExplicitPayerIdBuilder)); return *this; }
+ LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() { return &self; }
+ LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() { return &self; }
+ const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator &() const { return &self; }
+ const LDKInvoiceRequestWithExplicitPayerIdBuilder* operator ->() const { return &self; }
+};
+class InvoiceRequestWithDerivedPayerIdBuilder {
+private:
+ LDKInvoiceRequestWithDerivedPayerIdBuilder self;
+public:
+ InvoiceRequestWithDerivedPayerIdBuilder(const InvoiceRequestWithDerivedPayerIdBuilder&) = delete;
+ InvoiceRequestWithDerivedPayerIdBuilder(InvoiceRequestWithDerivedPayerIdBuilder&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); }
+ InvoiceRequestWithDerivedPayerIdBuilder(LDKInvoiceRequestWithDerivedPayerIdBuilder&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); }
+ operator LDKInvoiceRequestWithDerivedPayerIdBuilder() && { LDKInvoiceRequestWithDerivedPayerIdBuilder res = self; memset(&self, 0, sizeof(LDKInvoiceRequestWithDerivedPayerIdBuilder)); return res; }
+ ~InvoiceRequestWithDerivedPayerIdBuilder() { InvoiceRequestWithDerivedPayerIdBuilder_free(self); }
+ InvoiceRequestWithDerivedPayerIdBuilder& operator=(InvoiceRequestWithDerivedPayerIdBuilder&& o) { InvoiceRequestWithDerivedPayerIdBuilder_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestWithDerivedPayerIdBuilder)); return *this; }
+ LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() { return &self; }
+ LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() { return &self; }
+ const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator &() const { return &self; }
+ const LDKInvoiceRequestWithDerivedPayerIdBuilder* operator ->() const { return &self; }
+};
+class UnsignedInvoiceRequest {
+private:
+ LDKUnsignedInvoiceRequest self;
+public:
+ UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
+ UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
+ UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
+ operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
+ ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
+ UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
+ LDKUnsignedInvoiceRequest* operator &() { return &self; }
+ LDKUnsignedInvoiceRequest* operator ->() { return &self; }
+ const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
+ const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
+};
+class SignInvoiceRequestFn {
+private:
+ LDKSignInvoiceRequestFn self;
+public:
+ SignInvoiceRequestFn(const SignInvoiceRequestFn&) = delete;
+ SignInvoiceRequestFn(SignInvoiceRequestFn&& o) : self(o.self) { memset(&o, 0, sizeof(SignInvoiceRequestFn)); }
+ SignInvoiceRequestFn(LDKSignInvoiceRequestFn&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignInvoiceRequestFn)); }
+ operator LDKSignInvoiceRequestFn() && { LDKSignInvoiceRequestFn res = self; memset(&self, 0, sizeof(LDKSignInvoiceRequestFn)); return res; }
+ ~SignInvoiceRequestFn() { SignInvoiceRequestFn_free(self); }
+ SignInvoiceRequestFn& operator=(SignInvoiceRequestFn&& o) { SignInvoiceRequestFn_free(self); self = o.self; memset(&o, 0, sizeof(SignInvoiceRequestFn)); return *this; }
+ LDKSignInvoiceRequestFn* operator &() { return &self; }
+ LDKSignInvoiceRequestFn* operator ->() { return &self; }
+ const LDKSignInvoiceRequestFn* operator &() const { return &self; }
+ const LDKSignInvoiceRequestFn* operator ->() const { return &self; }
+ /**
+ * Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
+ */
+ inline LDK::CResult_SchnorrSignatureNoneZ sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message);
+};
+class InvoiceRequest {
+private:
+ LDKInvoiceRequest self;
+public:
+ InvoiceRequest(const InvoiceRequest&) = delete;
+ InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
+ InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
+ operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
+ ~InvoiceRequest() { InvoiceRequest_free(self); }
+ InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
+ LDKInvoiceRequest* operator &() { return &self; }
+ LDKInvoiceRequest* operator ->() { return &self; }
+ const LDKInvoiceRequest* operator &() const { return &self; }
+ const LDKInvoiceRequest* operator ->() const { return &self; }
+};
+class VerifiedInvoiceRequest {
+private:
+ LDKVerifiedInvoiceRequest self;
+public:
+ VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
+ VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
+ VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
+ operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
+ ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
+ VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
+ LDKVerifiedInvoiceRequest* operator &() { return &self; }
+ LDKVerifiedInvoiceRequest* operator ->() { return &self; }
+ const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
+ const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
+};
+class InvoiceRequestFields {
+private:
+ LDKInvoiceRequestFields self;
+public:
+ InvoiceRequestFields(const InvoiceRequestFields&) = delete;
+ InvoiceRequestFields(InvoiceRequestFields&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFields)); }
+ InvoiceRequestFields(LDKInvoiceRequestFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFields)); }
+ operator LDKInvoiceRequestFields() && { LDKInvoiceRequestFields res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFields)); return res; }
+ ~InvoiceRequestFields() { InvoiceRequestFields_free(self); }
+ InvoiceRequestFields& operator=(InvoiceRequestFields&& o) { InvoiceRequestFields_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFields)); return *this; }
+ LDKInvoiceRequestFields* operator &() { return &self; }
+ LDKInvoiceRequestFields* operator ->() { return &self; }
+ const LDKInvoiceRequestFields* operator &() const { return &self; }
+ const LDKInvoiceRequestFields* operator ->() const { return &self; }
+};
+class DecodeError {
+private:
+ LDKDecodeError self;
+public:
+ DecodeError(const DecodeError&) = delete;
+ DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
+ DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
+ operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
+ ~DecodeError() { DecodeError_free(self); }
+ DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
+ LDKDecodeError* operator &() { return &self; }
+ LDKDecodeError* operator ->() { return &self; }
+ const LDKDecodeError* operator &() const { return &self; }
+ const LDKDecodeError* operator ->() const { return &self; }
+};
+class Init {
+private:
+ LDKInit self;
+public:
+ Init(const Init&) = delete;
+ Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
+ Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
+ operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
+ ~Init() { Init_free(self); }
+ Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
+ LDKInit* operator &() { return &self; }
+ LDKInit* operator ->() { return &self; }
+ const LDKInit* operator &() const { return &self; }
+ const LDKInit* operator ->() const { return &self; }
+};
+class ErrorMessage {
+private:
+ LDKErrorMessage self;
+public:
+ ErrorMessage(const ErrorMessage&) = delete;
+ ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
+ ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
+ operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
+ ~ErrorMessage() { ErrorMessage_free(self); }
+ ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
+ LDKErrorMessage* operator &() { return &self; }
+ LDKErrorMessage* operator ->() { return &self; }
+ const LDKErrorMessage* operator &() const { return &self; }
+ const LDKErrorMessage* operator ->() const { return &self; }
+};
+class WarningMessage {
+private:
+ LDKWarningMessage self;
+public:
+ WarningMessage(const WarningMessage&) = delete;
+ WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
+ WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
+ operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
+ ~WarningMessage() { WarningMessage_free(self); }
+ WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
+ LDKWarningMessage* operator &() { return &self; }
+ LDKWarningMessage* operator ->() { return &self; }
+ const LDKWarningMessage* operator &() const { return &self; }
+ const LDKWarningMessage* operator ->() const { return &self; }
+};
+class Ping {
+private:
+ LDKPing self;
+public:
+ Ping(const Ping&) = delete;
+ Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
+ Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
+ operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
+ ~Ping() { Ping_free(self); }
+ Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
+ LDKPing* operator &() { return &self; }
+ LDKPing* operator ->() { return &self; }
+ const LDKPing* operator &() const { return &self; }
+ const LDKPing* operator ->() const { return &self; }
+};
+class Pong {
+private:
+ LDKPong self;
+public:
+ Pong(const Pong&) = delete;
+ Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
+ Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
+ operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
+ ~Pong() { Pong_free(self); }
+ Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
+ LDKPong* operator &() { return &self; }
+ LDKPong* operator ->() { return &self; }
+ const LDKPong* operator &() const { return &self; }
+ const LDKPong* operator ->() const { return &self; }
+};
+class CommonOpenChannelFields {
+private:
+ LDKCommonOpenChannelFields self;
+public:
+ CommonOpenChannelFields(const CommonOpenChannelFields&) = delete;
+ CommonOpenChannelFields(CommonOpenChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonOpenChannelFields)); }
+ CommonOpenChannelFields(LDKCommonOpenChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonOpenChannelFields)); }
+ operator LDKCommonOpenChannelFields() && { LDKCommonOpenChannelFields res = self; memset(&self, 0, sizeof(LDKCommonOpenChannelFields)); return res; }
+ ~CommonOpenChannelFields() { CommonOpenChannelFields_free(self); }
+ CommonOpenChannelFields& operator=(CommonOpenChannelFields&& o) { CommonOpenChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonOpenChannelFields)); return *this; }
+ LDKCommonOpenChannelFields* operator &() { return &self; }
+ LDKCommonOpenChannelFields* operator ->() { return &self; }
+ const LDKCommonOpenChannelFields* operator &() const { return &self; }
+ const LDKCommonOpenChannelFields* operator ->() const { return &self; }
+};
+class ChannelParameters {
+private:
+ LDKChannelParameters self;
+public:
+ ChannelParameters(const ChannelParameters&) = delete;
+ ChannelParameters(ChannelParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelParameters)); }
+ ChannelParameters(LDKChannelParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelParameters)); }
+ operator LDKChannelParameters() && { LDKChannelParameters res = self; memset(&self, 0, sizeof(LDKChannelParameters)); return res; }
+ ~ChannelParameters() { ChannelParameters_free(self); }
+ ChannelParameters& operator=(ChannelParameters&& o) { ChannelParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelParameters)); return *this; }
+ LDKChannelParameters* operator &() { return &self; }
+ LDKChannelParameters* operator ->() { return &self; }
+ const LDKChannelParameters* operator &() const { return &self; }
+ const LDKChannelParameters* operator ->() const { return &self; }
+};
+class OpenChannel {
+private:
+ LDKOpenChannel self;
+public:
+ OpenChannel(const OpenChannel&) = delete;
+ OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
+ OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
+ operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
+ ~OpenChannel() { OpenChannel_free(self); }
+ OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
+ LDKOpenChannel* operator &() { return &self; }
+ LDKOpenChannel* operator ->() { return &self; }
+ const LDKOpenChannel* operator &() const { return &self; }
+ const LDKOpenChannel* operator ->() const { return &self; }
+};
+class OpenChannelV2 {
+private:
+ LDKOpenChannelV2 self;
+public:
+ OpenChannelV2(const OpenChannelV2&) = delete;
+ OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
+ OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
+ operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
+ ~OpenChannelV2() { OpenChannelV2_free(self); }
+ OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
+ LDKOpenChannelV2* operator &() { return &self; }
+ LDKOpenChannelV2* operator ->() { return &self; }
+ const LDKOpenChannelV2* operator &() const { return &self; }
+ const LDKOpenChannelV2* operator ->() const { return &self; }
+};
+class CommonAcceptChannelFields {
+private:
+ LDKCommonAcceptChannelFields self;
+public:
+ CommonAcceptChannelFields(const CommonAcceptChannelFields&) = delete;
+ CommonAcceptChannelFields(CommonAcceptChannelFields&& o) : self(o.self) { memset(&o, 0, sizeof(CommonAcceptChannelFields)); }
+ CommonAcceptChannelFields(LDKCommonAcceptChannelFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommonAcceptChannelFields)); }
+ operator LDKCommonAcceptChannelFields() && { LDKCommonAcceptChannelFields res = self; memset(&self, 0, sizeof(LDKCommonAcceptChannelFields)); return res; }
+ ~CommonAcceptChannelFields() { CommonAcceptChannelFields_free(self); }
+ CommonAcceptChannelFields& operator=(CommonAcceptChannelFields&& o) { CommonAcceptChannelFields_free(self); self = o.self; memset(&o, 0, sizeof(CommonAcceptChannelFields)); return *this; }
+ LDKCommonAcceptChannelFields* operator &() { return &self; }
+ LDKCommonAcceptChannelFields* operator ->() { return &self; }
+ const LDKCommonAcceptChannelFields* operator &() const { return &self; }
+ const LDKCommonAcceptChannelFields* operator ->() const { return &self; }
+};
+class AcceptChannel {
+private:
+ LDKAcceptChannel self;
+public:
+ AcceptChannel(const AcceptChannel&) = delete;
+ AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
+ AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
+ operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
+ ~AcceptChannel() { AcceptChannel_free(self); }
+ AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
+ LDKAcceptChannel* operator &() { return &self; }
+ LDKAcceptChannel* operator ->() { return &self; }
+ const LDKAcceptChannel* operator &() const { return &self; }
+ const LDKAcceptChannel* operator ->() const { return &self; }
+};
+class AcceptChannelV2 {
+private:
+ LDKAcceptChannelV2 self;
+public:
+ AcceptChannelV2(const AcceptChannelV2&) = delete;
+ AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
+ AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
+ operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
+ ~AcceptChannelV2() { AcceptChannelV2_free(self); }
+ AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
+ LDKAcceptChannelV2* operator &() { return &self; }
+ LDKAcceptChannelV2* operator ->() { return &self; }
+ const LDKAcceptChannelV2* operator &() const { return &self; }
+ const LDKAcceptChannelV2* operator ->() const { return &self; }
+};
+class FundingCreated {
+private:
+ LDKFundingCreated self;
+public:
+ FundingCreated(const FundingCreated&) = delete;
+ FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
+ FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
+ operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
+ ~FundingCreated() { FundingCreated_free(self); }
+ FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
+ LDKFundingCreated* operator &() { return &self; }
+ LDKFundingCreated* operator ->() { return &self; }
+ const LDKFundingCreated* operator &() const { return &self; }
+ const LDKFundingCreated* operator ->() const { return &self; }
+};
+class FundingSigned {
+private:
+ LDKFundingSigned self;
+public:
+ FundingSigned(const FundingSigned&) = delete;
+ FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
+ FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
+ operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
+ ~FundingSigned() { FundingSigned_free(self); }
+ FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
+ LDKFundingSigned* operator &() { return &self; }
+ LDKFundingSigned* operator ->() { return &self; }
+ const LDKFundingSigned* operator &() const { return &self; }
+ const LDKFundingSigned* operator ->() const { return &self; }
+};
+class ChannelReady {
+private:
+ LDKChannelReady self;
+public:
+ ChannelReady(const ChannelReady&) = delete;
+ ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
+ ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
+ operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
+ ~ChannelReady() { ChannelReady_free(self); }
+ ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
+ LDKChannelReady* operator &() { return &self; }
+ LDKChannelReady* operator ->() { return &self; }
+ const LDKChannelReady* operator &() const { return &self; }
+ const LDKChannelReady* operator ->() const { return &self; }
+};
+class Stfu {
+private:
+ LDKStfu self;
+public:
+ Stfu(const Stfu&) = delete;
+ Stfu(Stfu&& o) : self(o.self) { memset(&o, 0, sizeof(Stfu)); }
+ Stfu(LDKStfu&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStfu)); }
+ operator LDKStfu() && { LDKStfu res = self; memset(&self, 0, sizeof(LDKStfu)); return res; }
+ ~Stfu() { Stfu_free(self); }
+ Stfu& operator=(Stfu&& o) { Stfu_free(self); self = o.self; memset(&o, 0, sizeof(Stfu)); return *this; }
+ LDKStfu* operator &() { return &self; }
+ LDKStfu* operator ->() { return &self; }
+ const LDKStfu* operator &() const { return &self; }
+ const LDKStfu* operator ->() const { return &self; }
+};
+class SpliceInit {
+private:
+ LDKSpliceInit self;
+public:
+ SpliceInit(const SpliceInit&) = delete;
+ SpliceInit(SpliceInit&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceInit)); }
+ SpliceInit(LDKSpliceInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceInit)); }
+ operator LDKSpliceInit() && { LDKSpliceInit res = self; memset(&self, 0, sizeof(LDKSpliceInit)); return res; }
+ ~SpliceInit() { SpliceInit_free(self); }
+ SpliceInit& operator=(SpliceInit&& o) { SpliceInit_free(self); self = o.self; memset(&o, 0, sizeof(SpliceInit)); return *this; }
+ LDKSpliceInit* operator &() { return &self; }
+ LDKSpliceInit* operator ->() { return &self; }
+ const LDKSpliceInit* operator &() const { return &self; }
+ const LDKSpliceInit* operator ->() const { return &self; }
+};
+class SpliceAck {
+private:
+ LDKSpliceAck self;
+public:
+ SpliceAck(const SpliceAck&) = delete;
+ SpliceAck(SpliceAck&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceAck)); }
+ SpliceAck(LDKSpliceAck&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceAck)); }
+ operator LDKSpliceAck() && { LDKSpliceAck res = self; memset(&self, 0, sizeof(LDKSpliceAck)); return res; }
+ ~SpliceAck() { SpliceAck_free(self); }
+ SpliceAck& operator=(SpliceAck&& o) { SpliceAck_free(self); self = o.self; memset(&o, 0, sizeof(SpliceAck)); return *this; }
+ LDKSpliceAck* operator &() { return &self; }
+ LDKSpliceAck* operator ->() { return &self; }
+ const LDKSpliceAck* operator &() const { return &self; }
+ const LDKSpliceAck* operator ->() const { return &self; }
+};
+class SpliceLocked {
+private:
+ LDKSpliceLocked self;
+public:
+ SpliceLocked(const SpliceLocked&) = delete;
+ SpliceLocked(SpliceLocked&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceLocked)); }
+ SpliceLocked(LDKSpliceLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceLocked)); }
+ operator LDKSpliceLocked() && { LDKSpliceLocked res = self; memset(&self, 0, sizeof(LDKSpliceLocked)); return res; }
+ ~SpliceLocked() { SpliceLocked_free(self); }
+ SpliceLocked& operator=(SpliceLocked&& o) { SpliceLocked_free(self); self = o.self; memset(&o, 0, sizeof(SpliceLocked)); return *this; }
+ LDKSpliceLocked* operator &() { return &self; }
+ LDKSpliceLocked* operator ->() { return &self; }
+ const LDKSpliceLocked* operator &() const { return &self; }
+ const LDKSpliceLocked* operator ->() const { return &self; }
+};
+class TxAddInput {
+private:
+ LDKTxAddInput self;
+public:
+ TxAddInput(const TxAddInput&) = delete;
+ TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
+ TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
+ operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
+ ~TxAddInput() { TxAddInput_free(self); }
+ TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
+ LDKTxAddInput* operator &() { return &self; }
+ LDKTxAddInput* operator ->() { return &self; }
+ const LDKTxAddInput* operator &() const { return &self; }
+ const LDKTxAddInput* operator ->() const { return &self; }
+};
+class TxAddOutput {
+private:
+ LDKTxAddOutput self;
+public:
+ TxAddOutput(const TxAddOutput&) = delete;
+ TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
+ TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
+ operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
+ ~TxAddOutput() { TxAddOutput_free(self); }
+ TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
+ LDKTxAddOutput* operator &() { return &self; }
+ LDKTxAddOutput* operator ->() { return &self; }
+ const LDKTxAddOutput* operator &() const { return &self; }
+ const LDKTxAddOutput* operator ->() const { return &self; }
+};
+class TxRemoveInput {
+private:
+ LDKTxRemoveInput self;
+public:
+ TxRemoveInput(const TxRemoveInput&) = delete;
+ TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
+ TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
+ operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
+ ~TxRemoveInput() { TxRemoveInput_free(self); }
+ TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
+ LDKTxRemoveInput* operator &() { return &self; }
+ LDKTxRemoveInput* operator ->() { return &self; }
+ const LDKTxRemoveInput* operator &() const { return &self; }
+ const LDKTxRemoveInput* operator ->() const { return &self; }
+};
+class TxRemoveOutput {
+private:
+ LDKTxRemoveOutput self;
+public:
+ TxRemoveOutput(const TxRemoveOutput&) = delete;
+ TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
+ TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
+ operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
+ ~TxRemoveOutput() { TxRemoveOutput_free(self); }
+ TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
+ LDKTxRemoveOutput* operator &() { return &self; }
+ LDKTxRemoveOutput* operator ->() { return &self; }
+ const LDKTxRemoveOutput* operator &() const { return &self; }
+ const LDKTxRemoveOutput* operator ->() const { return &self; }
+};
+class TxComplete {
+private:
+ LDKTxComplete self;
+public:
+ TxComplete(const TxComplete&) = delete;
+ TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
+ TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
+ operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
+ ~TxComplete() { TxComplete_free(self); }
+ TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
+ LDKTxComplete* operator &() { return &self; }
+ LDKTxComplete* operator ->() { return &self; }
+ const LDKTxComplete* operator &() const { return &self; }
+ const LDKTxComplete* operator ->() const { return &self; }
+};
+class TxSignatures {
+private:
+ LDKTxSignatures self;
+public:
+ TxSignatures(const TxSignatures&) = delete;
+ TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
+ TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
+ operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
+ ~TxSignatures() { TxSignatures_free(self); }
+ TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
+ LDKTxSignatures* operator &() { return &self; }
+ LDKTxSignatures* operator ->() { return &self; }
+ const LDKTxSignatures* operator &() const { return &self; }
+ const LDKTxSignatures* operator ->() const { return &self; }
+};
+class TxInitRbf {
+private:
+ LDKTxInitRbf self;
+public:
+ TxInitRbf(const TxInitRbf&) = delete;
+ TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
+ TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
+ operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
+ ~TxInitRbf() { TxInitRbf_free(self); }
+ TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
+ LDKTxInitRbf* operator &() { return &self; }
+ LDKTxInitRbf* operator ->() { return &self; }
+ const LDKTxInitRbf* operator &() const { return &self; }
+ const LDKTxInitRbf* operator ->() const { return &self; }
+};
+class TxAckRbf {
+private:
+ LDKTxAckRbf self;
+public:
+ TxAckRbf(const TxAckRbf&) = delete;
+ TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
+ TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
+ operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
+ ~TxAckRbf() { TxAckRbf_free(self); }
+ TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
+ LDKTxAckRbf* operator &() { return &self; }
+ LDKTxAckRbf* operator ->() { return &self; }
+ const LDKTxAckRbf* operator &() const { return &self; }
+ const LDKTxAckRbf* operator ->() const { return &self; }
+};
+class TxAbort {
+private:
+ LDKTxAbort self;
+public:
+ TxAbort(const TxAbort&) = delete;
+ TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
+ TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
+ operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
+ ~TxAbort() { TxAbort_free(self); }
+ TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
+ LDKTxAbort* operator &() { return &self; }
+ LDKTxAbort* operator ->() { return &self; }
+ const LDKTxAbort* operator &() const { return &self; }
+ const LDKTxAbort* operator ->() const { return &self; }
+};
+class Shutdown {
+private:
+ LDKShutdown self;
+public:
+ Shutdown(const Shutdown&) = delete;
+ Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
+ Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
+ operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
+ ~Shutdown() { Shutdown_free(self); }
+ Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
+ LDKShutdown* operator &() { return &self; }
+ LDKShutdown* operator ->() { return &self; }
+ const LDKShutdown* operator &() const { return &self; }
+ const LDKShutdown* operator ->() const { return &self; }
+};
+class ClosingSignedFeeRange {
+private:
+ LDKClosingSignedFeeRange self;
+public:
+ ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
+ ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
+ ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
+ operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
+ ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
+ ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
+ LDKClosingSignedFeeRange* operator &() { return &self; }
+ LDKClosingSignedFeeRange* operator ->() { return &self; }
+ const LDKClosingSignedFeeRange* operator &() const { return &self; }
+ const LDKClosingSignedFeeRange* operator ->() const { return &self; }
+};
+class ClosingSigned {
+private:
+ LDKClosingSigned self;
+public:
+ ClosingSigned(const ClosingSigned&) = delete;
+ ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
+ ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
+ operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
+ ~ClosingSigned() { ClosingSigned_free(self); }
+ ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
+ LDKClosingSigned* operator &() { return &self; }
+ LDKClosingSigned* operator ->() { return &self; }
+ const LDKClosingSigned* operator &() const { return &self; }
+ const LDKClosingSigned* operator ->() const { return &self; }
+};
+class UpdateAddHTLC {
+private:
+ LDKUpdateAddHTLC self;
+public:
+ UpdateAddHTLC(const UpdateAddHTLC&) = delete;
+ UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
+ UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
+ operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
+ ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
+ UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
+ LDKUpdateAddHTLC* operator &() { return &self; }
+ LDKUpdateAddHTLC* operator ->() { return &self; }
+ const LDKUpdateAddHTLC* operator &() const { return &self; }
+ const LDKUpdateAddHTLC* operator ->() const { return &self; }
+};
+class OnionMessage {
+private:
+ LDKOnionMessage self;
+public:
+ OnionMessage(const OnionMessage&) = delete;
+ OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
+ OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
+ operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
+ ~OnionMessage() { OnionMessage_free(self); }
+ OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
+ LDKOnionMessage* operator &() { return &self; }
+ LDKOnionMessage* operator ->() { return &self; }
+ const LDKOnionMessage* operator &() const { return &self; }
+ const LDKOnionMessage* operator ->() const { return &self; }
+};
+class UpdateFulfillHTLC {
+private:
+ LDKUpdateFulfillHTLC self;
+public:
+ UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
+ UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
+ UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
+ operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
+ ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
+ UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
+ LDKUpdateFulfillHTLC* operator &() { return &self; }
+ LDKUpdateFulfillHTLC* operator ->() { return &self; }
+ const LDKUpdateFulfillHTLC* operator &() const { return &self; }
+ const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
+};
+class UpdateFailHTLC {
+private:
+ LDKUpdateFailHTLC self;
+public:
+ UpdateFailHTLC(const UpdateFailHTLC&) = delete;
+ UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
+ UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
+ operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
+ ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
+ UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
+ LDKUpdateFailHTLC* operator &() { return &self; }
+ LDKUpdateFailHTLC* operator ->() { return &self; }
+ const LDKUpdateFailHTLC* operator &() const { return &self; }
+ const LDKUpdateFailHTLC* operator ->() const { return &self; }
+};
+class UpdateFailMalformedHTLC {
+private:
+ LDKUpdateFailMalformedHTLC self;
+public:
+ UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
+ UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
+ UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
+ operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
+ ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
+ UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
+ LDKUpdateFailMalformedHTLC* operator &() { return &self; }
+ LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
+ const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
+ const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
+};
+class CommitmentSignedBatch {
+private:
+ LDKCommitmentSignedBatch self;
+public:
+ CommitmentSignedBatch(const CommitmentSignedBatch&) = delete;
+ CommitmentSignedBatch(CommitmentSignedBatch&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSignedBatch)); }
+ CommitmentSignedBatch(LDKCommitmentSignedBatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSignedBatch)); }
+ operator LDKCommitmentSignedBatch() && { LDKCommitmentSignedBatch res = self; memset(&self, 0, sizeof(LDKCommitmentSignedBatch)); return res; }
+ ~CommitmentSignedBatch() { CommitmentSignedBatch_free(self); }
+ CommitmentSignedBatch& operator=(CommitmentSignedBatch&& o) { CommitmentSignedBatch_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSignedBatch)); return *this; }
+ LDKCommitmentSignedBatch* operator &() { return &self; }
+ LDKCommitmentSignedBatch* operator ->() { return &self; }
+ const LDKCommitmentSignedBatch* operator &() const { return &self; }
+ const LDKCommitmentSignedBatch* operator ->() const { return &self; }
+};
+class CommitmentSigned {
+private:
+ LDKCommitmentSigned self;
+public:
+ CommitmentSigned(const CommitmentSigned&) = delete;
+ CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
+ CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
+ operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
+ ~CommitmentSigned() { CommitmentSigned_free(self); }
+ CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
+ LDKCommitmentSigned* operator &() { return &self; }
+ LDKCommitmentSigned* operator ->() { return &self; }
+ const LDKCommitmentSigned* operator &() const { return &self; }
+ const LDKCommitmentSigned* operator ->() const { return &self; }
+};
+class RevokeAndACK {
+private:
+ LDKRevokeAndACK self;
+public:
+ RevokeAndACK(const RevokeAndACK&) = delete;
+ RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
+ RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
+ operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
+ ~RevokeAndACK() { RevokeAndACK_free(self); }
+ RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
+ LDKRevokeAndACK* operator &() { return &self; }
+ LDKRevokeAndACK* operator ->() { return &self; }
+ const LDKRevokeAndACK* operator &() const { return &self; }
+ const LDKRevokeAndACK* operator ->() const { return &self; }
+};
+class UpdateFee {
+private:
+ LDKUpdateFee self;
+public:
+ UpdateFee(const UpdateFee&) = delete;
+ UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
+ UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
+ operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
+ ~UpdateFee() { UpdateFee_free(self); }
+ UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
+ LDKUpdateFee* operator &() { return &self; }
+ LDKUpdateFee* operator ->() { return &self; }
+ const LDKUpdateFee* operator &() const { return &self; }
+ const LDKUpdateFee* operator ->() const { return &self; }
+};
+class ChannelReestablish {
+private:
+ LDKChannelReestablish self;
+public:
+ ChannelReestablish(const ChannelReestablish&) = delete;
+ ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
+ ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
+ operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
+ ~ChannelReestablish() { ChannelReestablish_free(self); }
+ ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
+ LDKChannelReestablish* operator &() { return &self; }
+ LDKChannelReestablish* operator ->() { return &self; }
+ const LDKChannelReestablish* operator &() const { return &self; }
+ const LDKChannelReestablish* operator ->() const { return &self; }
+};
+class AnnouncementSignatures {
+private:
+ LDKAnnouncementSignatures self;
+public:
+ AnnouncementSignatures(const AnnouncementSignatures&) = delete;
+ AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
+ AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
+ operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
+ ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
+ AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
+ LDKAnnouncementSignatures* operator &() { return &self; }
+ LDKAnnouncementSignatures* operator ->() { return &self; }
+ const LDKAnnouncementSignatures* operator &() const { return &self; }
+ const LDKAnnouncementSignatures* operator ->() const { return &self; }
+};
+class SocketAddress {
+private:
+ LDKSocketAddress self;
+public:
+ SocketAddress(const SocketAddress&) = delete;
+ SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
+ SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
+ operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
+ ~SocketAddress() { SocketAddress_free(self); }
+ SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
+ LDKSocketAddress* operator &() { return &self; }
+ LDKSocketAddress* operator ->() { return &self; }
+ const LDKSocketAddress* operator &() const { return &self; }
+ const LDKSocketAddress* operator ->() const { return &self; }
+};
+class SocketAddressParseError {
+private:
+ LDKSocketAddressParseError self;
+public:
+ SocketAddressParseError(const SocketAddressParseError&) = delete;
+ SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
+ SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
+ operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
+ SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
+ LDKSocketAddressParseError* operator &() { return &self; }
+ LDKSocketAddressParseError* operator ->() { return &self; }
+ const LDKSocketAddressParseError* operator &() const { return &self; }
+ const LDKSocketAddressParseError* operator ->() const { return &self; }
+};
+class UnsignedGossipMessage {
+private:
+ LDKUnsignedGossipMessage self;
+public:
+ UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
+ UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
+ UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
+ operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
+ ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
+ UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
+ LDKUnsignedGossipMessage* operator &() { return &self; }
+ LDKUnsignedGossipMessage* operator ->() { return &self; }
+ const LDKUnsignedGossipMessage* operator &() const { return &self; }
+ const LDKUnsignedGossipMessage* operator ->() const { return &self; }
+};
+class UnsignedNodeAnnouncement {
+private:
+ LDKUnsignedNodeAnnouncement self;
+public:
+ UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
+ UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
+ UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
+ operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
+ ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
+ UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
+ LDKUnsignedNodeAnnouncement* operator &() { return &self; }
+ LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
+ const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
+ const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
+};
+class NodeAnnouncement {
+private:
+ LDKNodeAnnouncement self;
+public:
+ NodeAnnouncement(const NodeAnnouncement&) = delete;
+ NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
+ NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
+ operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
+ ~NodeAnnouncement() { NodeAnnouncement_free(self); }
+ NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
+ LDKNodeAnnouncement* operator &() { return &self; }
+ LDKNodeAnnouncement* operator ->() { return &self; }
+ const LDKNodeAnnouncement* operator &() const { return &self; }
+ const LDKNodeAnnouncement* operator ->() const { return &self; }
+};
+class UnsignedChannelAnnouncement {
+private:
+ LDKUnsignedChannelAnnouncement self;
+public:
+ UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
+ UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
+ UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
+ operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
+ ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
+ UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
+ LDKUnsignedChannelAnnouncement* operator &() { return &self; }
+ LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
+ const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
+ const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
+};
+class ChannelAnnouncement {
+private:
+ LDKChannelAnnouncement self;
+public:
+ ChannelAnnouncement(const ChannelAnnouncement&) = delete;
+ ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
+ ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
+ operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
+ ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
+ ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
+ LDKChannelAnnouncement* operator &() { return &self; }
+ LDKChannelAnnouncement* operator ->() { return &self; }
+ const LDKChannelAnnouncement* operator &() const { return &self; }
+ const LDKChannelAnnouncement* operator ->() const { return &self; }
+};
+class UnsignedChannelUpdate {
+private:
+ LDKUnsignedChannelUpdate self;
+public:
+ UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
+ UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
+ UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
+ operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
+ ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
+ UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
+ LDKUnsignedChannelUpdate* operator &() { return &self; }
+ LDKUnsignedChannelUpdate* operator ->() { return &self; }
+ const LDKUnsignedChannelUpdate* operator &() const { return &self; }
+ const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
+};
+class ChannelUpdate {
+private:
+ LDKChannelUpdate self;
+public:
+ ChannelUpdate(const ChannelUpdate&) = delete;
+ ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
+ ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
+ operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
+ ~ChannelUpdate() { ChannelUpdate_free(self); }
+ ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
+ LDKChannelUpdate* operator &() { return &self; }
+ LDKChannelUpdate* operator ->() { return &self; }
+ const LDKChannelUpdate* operator &() const { return &self; }
+ const LDKChannelUpdate* operator ->() const { return &self; }
+};
+class QueryChannelRange {
+private:
+ LDKQueryChannelRange self;
+public:
+ QueryChannelRange(const QueryChannelRange&) = delete;
+ QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
+ QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
+ operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
+ ~QueryChannelRange() { QueryChannelRange_free(self); }
+ QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
+ LDKQueryChannelRange* operator &() { return &self; }
+ LDKQueryChannelRange* operator ->() { return &self; }
+ const LDKQueryChannelRange* operator &() const { return &self; }
+ const LDKQueryChannelRange* operator ->() const { return &self; }
+};
+class ReplyChannelRange {
+private:
+ LDKReplyChannelRange self;
+public:
+ ReplyChannelRange(const ReplyChannelRange&) = delete;
+ ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
+ ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
+ operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
+ ~ReplyChannelRange() { ReplyChannelRange_free(self); }
+ ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
+ LDKReplyChannelRange* operator &() { return &self; }
+ LDKReplyChannelRange* operator ->() { return &self; }
+ const LDKReplyChannelRange* operator &() const { return &self; }
+ const LDKReplyChannelRange* operator ->() const { return &self; }
+};
+class QueryShortChannelIds {
+private:
+ LDKQueryShortChannelIds self;
+public:
+ QueryShortChannelIds(const QueryShortChannelIds&) = delete;
+ QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
+ QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
+ operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
+ ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
+ QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
+ LDKQueryShortChannelIds* operator &() { return &self; }
+ LDKQueryShortChannelIds* operator ->() { return &self; }
+ const LDKQueryShortChannelIds* operator &() const { return &self; }
+ const LDKQueryShortChannelIds* operator ->() const { return &self; }
+};
+class ReplyShortChannelIdsEnd {
+private:
+ LDKReplyShortChannelIdsEnd self;
+public:
+ ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
+ ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
+ ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
+ operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
+ ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
+ ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
+ LDKReplyShortChannelIdsEnd* operator &() { return &self; }
+ LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
+ const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
+ const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
+};
+class GossipTimestampFilter {
+private:
+ LDKGossipTimestampFilter self;
+public:
+ GossipTimestampFilter(const GossipTimestampFilter&) = delete;
+ GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
+ GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
+ operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
+ ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
+ GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
+ LDKGossipTimestampFilter* operator &() { return &self; }
+ LDKGossipTimestampFilter* operator ->() { return &self; }
+ const LDKGossipTimestampFilter* operator &() const { return &self; }
+ const LDKGossipTimestampFilter* operator ->() const { return &self; }
+};
+class ErrorAction {
+private:
+ LDKErrorAction self;
+public:
+ ErrorAction(const ErrorAction&) = delete;
+ ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
+ ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
+ operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
+ ~ErrorAction() { ErrorAction_free(self); }
+ ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
+ LDKErrorAction* operator &() { return &self; }
+ LDKErrorAction* operator ->() { return &self; }
+ const LDKErrorAction* operator &() const { return &self; }
+ const LDKErrorAction* operator ->() const { return &self; }
+};
+class LightningError {
+private:
+ LDKLightningError self;
+public:
+ LightningError(const LightningError&) = delete;
+ LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
+ LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
+ operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
+ ~LightningError() { LightningError_free(self); }
+ LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
+ LDKLightningError* operator &() { return &self; }
+ LDKLightningError* operator ->() { return &self; }
+ const LDKLightningError* operator &() const { return &self; }
+ const LDKLightningError* operator ->() const { return &self; }
+};
+class CommitmentUpdate {
+private:
+ LDKCommitmentUpdate self;
+public:
+ CommitmentUpdate(const CommitmentUpdate&) = delete;
+ CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
+ CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
+ operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
+ ~CommitmentUpdate() { CommitmentUpdate_free(self); }
+ CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
+ LDKCommitmentUpdate* operator &() { return &self; }
+ LDKCommitmentUpdate* operator ->() { return &self; }
+ const LDKCommitmentUpdate* operator &() const { return &self; }
+ const LDKCommitmentUpdate* operator ->() const { return &self; }
+};
+class ChannelMessageHandler {
+private:
+ LDKChannelMessageHandler self;
+public:
+ ChannelMessageHandler(const ChannelMessageHandler&) = delete;
+ ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
+ ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
+ operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
+ ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
+ ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
+ LDKChannelMessageHandler* operator &() { return &self; }
+ LDKChannelMessageHandler* operator ->() { return &self; }
+ const LDKChannelMessageHandler* operator &() const { return &self; }
+ const LDKChannelMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `open_channel` message from the given peer.
+ */
+ inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `open_channel2` message from the given peer.
+ */
+ inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `accept_channel` message from the given peer.
+ */
+ inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `accept_channel2` message from the given peer.
+ */
+ inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `funding_created` message from the given peer.
+ */
+ inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `funding_signed` message from the given peer.
+ */
+ inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_ready` message from the given peer.
+ */
+ inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `shutdown` message from the given peer.
+ */
+ inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `closing_signed` message from the given peer.
+ */
+ inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `stfu` message from the given peer.
+ */
+ inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_add_input message` from the given peer.
+ */
+ inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_add_output` message from the given peer.
+ */
+ inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_remove_input` message from the given peer.
+ */
+ inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_remove_output` message from the given peer.
+ */
+ inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_complete message` from the given peer.
+ */
+ inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_signatures` message from the given peer.
+ */
+ inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_init_rbf` message from the given peer.
+ */
+ inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_ack_rbf` message from the given peer.
+ */
+ inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `tx_abort message` from the given peer.
+ */
+ inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_add_htlc` message from the given peer.
+ */
+ inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fulfill_htlc` message from the given peer.
+ */
+ inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fail_htlc` message from the given peer.
+ */
+ inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fail_malformed_htlc` message from the given peer.
+ */
+ inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `commitment_signed` message from the given peer.
+ */
+ inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `revoke_and_ack` message from the given peer.
+ */
+ inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `update_fee` message from the given peer.
+ */
+ inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `announcement_signatures` message from the given peer.
+ */
+ inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
+ /**
+ * Indicates a connection to the peer failed/an existing connection was lost.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
+ /**
+ * Handle an incoming `channel_reestablish` message from the given peer.
+ */
+ inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_update` message from the given peer.
+ */
+ inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `error` message from the given peer.
+ */
+ inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+ /**
+ * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
+ *
+ * If it's `None`, then no particular network chain hash compatibility will be enforced when
+ * connecting to peers.
+ */
+ inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
+};
+class RoutingMessageHandler {
+private:
+ LDKRoutingMessageHandler self;
+public:
+ RoutingMessageHandler(const RoutingMessageHandler&) = delete;
+ RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
+ RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
+ operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
+ ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
+ RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
+ LDKRoutingMessageHandler* operator &() { return &self; }
+ LDKRoutingMessageHandler* operator ->() { return &self; }
+ const LDKRoutingMessageHandler* operator &() const { return &self; }
+ const LDKRoutingMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
+ * `false` or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
+ /**
+ * Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
+ * or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
+ /**
+ * Handle an incoming `channel_update` message, returning true if it should be forwarded on,
+ * `false` or returning an `Err` otherwise.
+ */
+ inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
+ /**
+ * Gets channel announcements and updates required to dump our routing table to a remote node,
+ * starting at the `short_channel_id` indicated by `starting_point` and including announcements
+ * for a single channel.
+ */
+ inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
+ /**
+ * Gets a node announcement required to dump our routing table to a remote node, starting at
+ * the node *after* the provided pubkey and including up to one announcement immediately
+ * higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
+ * If `None` is provided for `starting_point`, we start at the first node.
+ *
+ * Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
+ /**
+ * Called when a connection is established with a peer. This can be used to
+ * perform routing table synchronization using a strategy defined by the
+ * implementor.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
+ /**
+ * Handles the reply of a query we initiated to learn about channels
+ * for a given range of blocks. We can expect to receive one or more
+ * replies to a single query.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
+ /**
+ * Handles the reply of a query we initiated asking for routing gossip
+ * messages for a list of channels. We should receive this message when
+ * a node has completed its best effort to send us the pertaining routing
+ * gossip messages.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
+ /**
+ * Handles when a peer asks us to send a list of `short_channel_id`s
+ * for the requested range of blocks.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
+ /**
+ * Handles when a peer asks us to send routing gossip messages for a
+ * list of `short_channel_id`s.
+ */
+ inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
+ /**
+ * Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
+ * pending some async action. While there is no guarantee of the rate of future messages, the
+ * caller should seek to reduce the rate of new gossip messages handled, especially
+ * [`ChannelAnnouncement`]s.
+ */
+ inline bool processing_queue_high();
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class OnionMessageHandler {
+private:
+ LDKOnionMessageHandler self;
+public:
+ OnionMessageHandler(const OnionMessageHandler&) = delete;
+ OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
+ OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
+ operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
+ ~OnionMessageHandler() { OnionMessageHandler_free(self); }
+ OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
+ LDKOnionMessageHandler* operator &() { return &self; }
+ LDKOnionMessageHandler* operator ->() { return &self; }
+ const LDKOnionMessageHandler* operator &() const { return &self; }
+ const LDKOnionMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle an incoming `onion_message` message from the given peer.
+ */
+ inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
+ /**
+ * Returns the next pending onion message for the peer with the given node id.
+ *
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
+ /**
+ * Called when a connection is established with a peer. Can be used to track which peers
+ * advertise onion message support and are online.
+ *
+ * May return an `Err(())` if the features the peer supports are not sufficient to communicate
+ * with us. Implementors should be somewhat conservative about doing so, however, as other
+ * message handlers may still wish to communicate with this peer.
+ */
+ inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
+ /**
+ * Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
+ * drop and refuse to forward onion messages to this peer.
+ */
+ inline void peer_disconnected(struct LDKPublicKey their_node_id);
+ /**
+ * Performs actions that should happen roughly every ten seconds after startup. Allows handlers
+ * to drop any buffered onion messages intended for prospective peers.
+ */
+ inline void timer_tick_occurred();
+ /**
+ * Gets the node feature flags which this handler itself supports. All available handlers are
+ * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
+ * which are broadcasted in our [`NodeAnnouncement`] message.
+ */
+ inline LDK::NodeFeatures provided_node_features();
+ /**
+ * Gets the init feature flags which should be sent to the given peer. All available handlers
+ * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
+ * which are sent in our [`Init`] message.
+ *
+ * Note that this method is called before [`Self::peer_connected`].
+ */
+ inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
+};
+class FinalOnionHopData {
+private:
+ LDKFinalOnionHopData self;
+public:
+ FinalOnionHopData(const FinalOnionHopData&) = delete;
+ FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
+ FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
+ operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
+ ~FinalOnionHopData() { FinalOnionHopData_free(self); }
+ FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
+ LDKFinalOnionHopData* operator &() { return &self; }
+ LDKFinalOnionHopData* operator ->() { return &self; }
+ const LDKFinalOnionHopData* operator &() const { return &self; }
+ const LDKFinalOnionHopData* operator ->() const { return &self; }
+};
+class OnionPacket {
+private:
+ LDKOnionPacket self;
+public:
+ OnionPacket(const OnionPacket&) = delete;
+ OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
+ OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
+ operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
+ ~OnionPacket() { OnionPacket_free(self); }
+ OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
+ LDKOnionPacket* operator &() { return &self; }
+ LDKOnionPacket* operator ->() { return &self; }
+ const LDKOnionPacket* operator &() const { return &self; }
+ const LDKOnionPacket* operator ->() const { return &self; }
+};
+class TrampolineOnionPacket {
+private:
+ LDKTrampolineOnionPacket self;
+public:
+ TrampolineOnionPacket(const TrampolineOnionPacket&) = delete;
+ TrampolineOnionPacket(TrampolineOnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(TrampolineOnionPacket)); }
+ TrampolineOnionPacket(LDKTrampolineOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrampolineOnionPacket)); }
+ operator LDKTrampolineOnionPacket() && { LDKTrampolineOnionPacket res = self; memset(&self, 0, sizeof(LDKTrampolineOnionPacket)); return res; }
+ ~TrampolineOnionPacket() { TrampolineOnionPacket_free(self); }
+ TrampolineOnionPacket& operator=(TrampolineOnionPacket&& o) { TrampolineOnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(TrampolineOnionPacket)); return *this; }
+ LDKTrampolineOnionPacket* operator &() { return &self; }
+ LDKTrampolineOnionPacket* operator ->() { return &self; }
+ const LDKTrampolineOnionPacket* operator &() const { return &self; }
+ const LDKTrampolineOnionPacket* operator ->() const { return &self; }
+};
+class Level {
+private:
+ LDKLevel self;
+public:
+ Level(const Level&) = delete;
+ Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
+ Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
+ operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
+ Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
+ LDKLevel* operator &() { return &self; }
+ LDKLevel* operator ->() { return &self; }
+ const LDKLevel* operator &() const { return &self; }
+ const LDKLevel* operator ->() const { return &self; }
+};
+class Record {
+private:
+ LDKRecord self;
+public:
+ Record(const Record&) = delete;
+ Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
+ Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
+ operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
+ ~Record() { Record_free(self); }
+ Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
+ LDKRecord* operator &() { return &self; }
+ LDKRecord* operator ->() { return &self; }
+ const LDKRecord* operator &() const { return &self; }
+ const LDKRecord* operator ->() const { return &self; }
+};
+class Logger {
+private:
+ LDKLogger self;
+public:
+ Logger(const Logger&) = delete;
+ Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
+ Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
+ operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
+ ~Logger() { Logger_free(self); }
+ Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
+ LDKLogger* operator &() { return &self; }
+ LDKLogger* operator ->() { return &self; }
+ const LDKLogger* operator &() const { return &self; }
+ const LDKLogger* operator ->() const { return &self; }
+ /**
+ * Logs the [`Record`].
+ */
+ inline void log(struct LDKRecord record);
+};
+class InboundHTLCStateDetails {
+private:
+ LDKInboundHTLCStateDetails self;
+public:
+ InboundHTLCStateDetails(const InboundHTLCStateDetails&) = delete;
+ InboundHTLCStateDetails(InboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCStateDetails)); }
+ InboundHTLCStateDetails(LDKInboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCStateDetails)); }
+ operator LDKInboundHTLCStateDetails() && { LDKInboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCStateDetails)); return res; }
+ InboundHTLCStateDetails& operator=(InboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(InboundHTLCStateDetails)); return *this; }
+ LDKInboundHTLCStateDetails* operator &() { return &self; }
+ LDKInboundHTLCStateDetails* operator ->() { return &self; }
+ const LDKInboundHTLCStateDetails* operator &() const { return &self; }
+ const LDKInboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class InboundHTLCDetails {
+private:
+ LDKInboundHTLCDetails self;
+public:
+ InboundHTLCDetails(const InboundHTLCDetails&) = delete;
+ InboundHTLCDetails(InboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCDetails)); }
+ InboundHTLCDetails(LDKInboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCDetails)); }
+ operator LDKInboundHTLCDetails() && { LDKInboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKInboundHTLCDetails)); return res; }
+ ~InboundHTLCDetails() { InboundHTLCDetails_free(self); }
+ InboundHTLCDetails& operator=(InboundHTLCDetails&& o) { InboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCDetails)); return *this; }
+ LDKInboundHTLCDetails* operator &() { return &self; }
+ LDKInboundHTLCDetails* operator ->() { return &self; }
+ const LDKInboundHTLCDetails* operator &() const { return &self; }
+ const LDKInboundHTLCDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCStateDetails {
+private:
+ LDKOutboundHTLCStateDetails self;
+public:
+ OutboundHTLCStateDetails(const OutboundHTLCStateDetails&) = delete;
+ OutboundHTLCStateDetails(OutboundHTLCStateDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCStateDetails)); }
+ OutboundHTLCStateDetails(LDKOutboundHTLCStateDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCStateDetails)); }
+ operator LDKOutboundHTLCStateDetails() && { LDKOutboundHTLCStateDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCStateDetails)); return res; }
+ OutboundHTLCStateDetails& operator=(OutboundHTLCStateDetails&& o) { self = o.self; memset(&o, 0, sizeof(OutboundHTLCStateDetails)); return *this; }
+ LDKOutboundHTLCStateDetails* operator &() { return &self; }
+ LDKOutboundHTLCStateDetails* operator ->() { return &self; }
+ const LDKOutboundHTLCStateDetails* operator &() const { return &self; }
+ const LDKOutboundHTLCStateDetails* operator ->() const { return &self; }
+};
+class OutboundHTLCDetails {
+private:
+ LDKOutboundHTLCDetails self;
+public:
+ OutboundHTLCDetails(const OutboundHTLCDetails&) = delete;
+ OutboundHTLCDetails(OutboundHTLCDetails&& o) : self(o.self) { memset(&o, 0, sizeof(OutboundHTLCDetails)); }
+ OutboundHTLCDetails(LDKOutboundHTLCDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutboundHTLCDetails)); }
+ operator LDKOutboundHTLCDetails() && { LDKOutboundHTLCDetails res = self; memset(&self, 0, sizeof(LDKOutboundHTLCDetails)); return res; }
+ ~OutboundHTLCDetails() { OutboundHTLCDetails_free(self); }
+ OutboundHTLCDetails& operator=(OutboundHTLCDetails&& o) { OutboundHTLCDetails_free(self); self = o.self; memset(&o, 0, sizeof(OutboundHTLCDetails)); return *this; }
+ LDKOutboundHTLCDetails* operator &() { return &self; }
+ LDKOutboundHTLCDetails* operator ->() { return &self; }
+ const LDKOutboundHTLCDetails* operator &() const { return &self; }
+ const LDKOutboundHTLCDetails* operator ->() const { return &self; }
+};
+class CounterpartyForwardingInfo {
+private:
+ LDKCounterpartyForwardingInfo self;
+public:
+ CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
+ CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
+ CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
+ operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
+ ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
+ CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
+ LDKCounterpartyForwardingInfo* operator &() { return &self; }
+ LDKCounterpartyForwardingInfo* operator ->() { return &self; }
+ const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
+ const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
+};
+class ChannelCounterparty {
+private:
+ LDKChannelCounterparty self;
+public:
+ ChannelCounterparty(const ChannelCounterparty&) = delete;
+ ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
+ ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
+ operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
+ ~ChannelCounterparty() { ChannelCounterparty_free(self); }
+ ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
+ LDKChannelCounterparty* operator &() { return &self; }
+ LDKChannelCounterparty* operator ->() { return &self; }
+ const LDKChannelCounterparty* operator &() const { return &self; }
+ const LDKChannelCounterparty* operator ->() const { return &self; }
+};
+class ChannelDetails {
+private:
+ LDKChannelDetails self;
+public:
+ ChannelDetails(const ChannelDetails&) = delete;
+ ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
+ ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
+ operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
+ ~ChannelDetails() { ChannelDetails_free(self); }
+ ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
+ LDKChannelDetails* operator &() { return &self; }
+ LDKChannelDetails* operator ->() { return &self; }
+ const LDKChannelDetails* operator &() const { return &self; }
+ const LDKChannelDetails* operator ->() const { return &self; }
+};
+class ChannelShutdownState {
+private:
+ LDKChannelShutdownState self;
+public:
+ ChannelShutdownState(const ChannelShutdownState&) = delete;
+ ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
+ ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
+ operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
+ ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
+ LDKChannelShutdownState* operator &() { return &self; }
+ LDKChannelShutdownState* operator ->() { return &self; }
+ const LDKChannelShutdownState* operator &() const { return &self; }
+ const LDKChannelShutdownState* operator ->() const { return &self; }
+};
+class FutureCallback {
+private:
+ LDKFutureCallback self;
+public:
+ FutureCallback(const FutureCallback&) = delete;
+ FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
+ FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
+ operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
+ ~FutureCallback() { FutureCallback_free(self); }
+ FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
+ LDKFutureCallback* operator &() { return &self; }
+ LDKFutureCallback* operator ->() { return &self; }
+ const LDKFutureCallback* operator &() const { return &self; }
+ const LDKFutureCallback* operator ->() const { return &self; }
+ /**
+ * The method which is called.
+ */
+ inline void call();
+};
+class Future {
+private:
+ LDKFuture self;
+public:
+ Future(const Future&) = delete;
+ Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
+ Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
+ operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
+ ~Future() { Future_free(self); }
+ Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
+ LDKFuture* operator &() { return &self; }
+ LDKFuture* operator ->() { return &self; }
+ const LDKFuture* operator &() const { return &self; }
+ const LDKFuture* operator ->() const { return &self; }
+};
+class Sleeper {
+private:
+ LDKSleeper self;
+public:
+ Sleeper(const Sleeper&) = delete;
+ Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
+ Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
+ operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
+ ~Sleeper() { Sleeper_free(self); }
+ Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
+ LDKSleeper* operator &() { return &self; }
+ LDKSleeper* operator ->() { return &self; }
+ const LDKSleeper* operator &() const { return &self; }
+ const LDKSleeper* operator ->() const { return &self; }
+};
+class AsyncPaymentsMessageHandler {
+private:
+ LDKAsyncPaymentsMessageHandler self;
+public:
+ AsyncPaymentsMessageHandler(const AsyncPaymentsMessageHandler&) = delete;
+ AsyncPaymentsMessageHandler(AsyncPaymentsMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); }
+ AsyncPaymentsMessageHandler(LDKAsyncPaymentsMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); }
+ operator LDKAsyncPaymentsMessageHandler() && { LDKAsyncPaymentsMessageHandler res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessageHandler)); return res; }
+ ~AsyncPaymentsMessageHandler() { AsyncPaymentsMessageHandler_free(self); }
+ AsyncPaymentsMessageHandler& operator=(AsyncPaymentsMessageHandler&& o) { AsyncPaymentsMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessageHandler)); return *this; }
+ LDKAsyncPaymentsMessageHandler* operator &() { return &self; }
+ LDKAsyncPaymentsMessageHandler* operator ->() { return &self; }
+ const LDKAsyncPaymentsMessageHandler* operator &() const { return &self; }
+ const LDKAsyncPaymentsMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handle a [`HeldHtlcAvailable`] message. A [`ReleaseHeldHtlc`] should be returned to release
+ * the held funds.
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ held_htlc_available(struct LDKHeldHtlcAvailable message, struct LDKResponder responder);
+ /**
+ * Handle a [`ReleaseHeldHtlc`] message. If authentication of the message succeeds, an HTLC
+ * should be released to the corresponding payee.
+ */
+ inline void release_held_htlc(struct LDKReleaseHeldHtlc message);
+ /**
+ * Release any [`AsyncPaymentsMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating an async payment flow rather than in response
+ * to another message.
+ */
+ inline LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class AsyncPaymentsMessage {
+private:
+ LDKAsyncPaymentsMessage self;
+public:
+ AsyncPaymentsMessage(const AsyncPaymentsMessage&) = delete;
+ AsyncPaymentsMessage(AsyncPaymentsMessage&& o) : self(o.self) { memset(&o, 0, sizeof(AsyncPaymentsMessage)); }
+ AsyncPaymentsMessage(LDKAsyncPaymentsMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAsyncPaymentsMessage)); }
+ operator LDKAsyncPaymentsMessage() && { LDKAsyncPaymentsMessage res = self; memset(&self, 0, sizeof(LDKAsyncPaymentsMessage)); return res; }
+ ~AsyncPaymentsMessage() { AsyncPaymentsMessage_free(self); }
+ AsyncPaymentsMessage& operator=(AsyncPaymentsMessage&& o) { AsyncPaymentsMessage_free(self); self = o.self; memset(&o, 0, sizeof(AsyncPaymentsMessage)); return *this; }
+ LDKAsyncPaymentsMessage* operator &() { return &self; }
+ LDKAsyncPaymentsMessage* operator ->() { return &self; }
+ const LDKAsyncPaymentsMessage* operator &() const { return &self; }
+ const LDKAsyncPaymentsMessage* operator ->() const { return &self; }
+};
+class HeldHtlcAvailable {
+private:
+ LDKHeldHtlcAvailable self;
+public:
+ HeldHtlcAvailable(const HeldHtlcAvailable&) = delete;
+ HeldHtlcAvailable(HeldHtlcAvailable&& o) : self(o.self) { memset(&o, 0, sizeof(HeldHtlcAvailable)); }
+ HeldHtlcAvailable(LDKHeldHtlcAvailable&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHeldHtlcAvailable)); }
+ operator LDKHeldHtlcAvailable() && { LDKHeldHtlcAvailable res = self; memset(&self, 0, sizeof(LDKHeldHtlcAvailable)); return res; }
+ ~HeldHtlcAvailable() { HeldHtlcAvailable_free(self); }
+ HeldHtlcAvailable& operator=(HeldHtlcAvailable&& o) { HeldHtlcAvailable_free(self); self = o.self; memset(&o, 0, sizeof(HeldHtlcAvailable)); return *this; }
+ LDKHeldHtlcAvailable* operator &() { return &self; }
+ LDKHeldHtlcAvailable* operator ->() { return &self; }
+ const LDKHeldHtlcAvailable* operator &() const { return &self; }
+ const LDKHeldHtlcAvailable* operator ->() const { return &self; }
+};
+class ReleaseHeldHtlc {
+private:
+ LDKReleaseHeldHtlc self;
+public:
+ ReleaseHeldHtlc(const ReleaseHeldHtlc&) = delete;
+ ReleaseHeldHtlc(ReleaseHeldHtlc&& o) : self(o.self) { memset(&o, 0, sizeof(ReleaseHeldHtlc)); }
+ ReleaseHeldHtlc(LDKReleaseHeldHtlc&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReleaseHeldHtlc)); }
+ operator LDKReleaseHeldHtlc() && { LDKReleaseHeldHtlc res = self; memset(&self, 0, sizeof(LDKReleaseHeldHtlc)); return res; }
+ ~ReleaseHeldHtlc() { ReleaseHeldHtlc_free(self); }
+ ReleaseHeldHtlc& operator=(ReleaseHeldHtlc&& o) { ReleaseHeldHtlc_free(self); self = o.self; memset(&o, 0, sizeof(ReleaseHeldHtlc)); return *this; }
+ LDKReleaseHeldHtlc* operator &() { return &self; }
+ LDKReleaseHeldHtlc* operator ->() { return &self; }
+ const LDKReleaseHeldHtlc* operator &() const { return &self; }
+ const LDKReleaseHeldHtlc* operator ->() const { return &self; }
+};
+class OffersMessageHandler {
+private:
+ LDKOffersMessageHandler self;
+public:
+ OffersMessageHandler(const OffersMessageHandler&) = delete;
+ OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
+ OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
+ operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
+ ~OffersMessageHandler() { OffersMessageHandler_free(self); }
+ OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
+ LDKOffersMessageHandler* operator &() { return &self; }
+ LDKOffersMessageHandler* operator ->() { return &self; }
+ const LDKOffersMessageHandler* operator &() const { return &self; }
+ const LDKOffersMessageHandler* operator ->() const { return &self; }
+ /**
+ * Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
+ * or replying with an error.
+ *
+ * The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
+ *
+ * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
+ *
+ * Note that responder (or a relevant inner pointer) may be NULL or all-0s to represent None
+ */
+ inline LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ handle_message(struct LDKOffersMessage message, struct LDKCOption_OffersContextZ context, struct LDKResponder responder);
+ /**
+ * Releases any [`OffersMessage`]s that need to be sent.
+ *
+ * Typically, this is used for messages initiating a payment flow rather than in response to
+ * another message. The latter should use the return value of [`Self::handle_message`].
+ */
+ inline LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ release_pending_messages();
+};
+class OffersMessage {
+private:
+ LDKOffersMessage self;
+public:
+ OffersMessage(const OffersMessage&) = delete;
+ OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
+ OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
+ operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
+ ~OffersMessage() { OffersMessage_free(self); }
+ OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
+ LDKOffersMessage* operator &() { return &self; }
+ LDKOffersMessage* operator ->() { return &self; }
+ const LDKOffersMessage* operator &() const { return &self; }
+ const LDKOffersMessage* operator ->() const { return &self; }
+};
+class HTLCClaim {
+private:
+ LDKHTLCClaim self;
+public:
+ HTLCClaim(const HTLCClaim&) = delete;
+ HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
+ HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
+ operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
+ HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
+ LDKHTLCClaim* operator &() { return &self; }
+ LDKHTLCClaim* operator ->() { return &self; }
+ const LDKHTLCClaim* operator &() const { return &self; }
+ const LDKHTLCClaim* operator ->() const { return &self; }
+};
+class CounterpartyCommitmentSecrets {
+private:
+ LDKCounterpartyCommitmentSecrets self;
+public:
+ CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
+ CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
+ CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
+ operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
+ ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
+ CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
+ LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
+ LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
+ const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
+ const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
+};
+class TxCreationKeys {
+private:
+ LDKTxCreationKeys self;
+public:
+ TxCreationKeys(const TxCreationKeys&) = delete;
+ TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
+ TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
+ operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
+ ~TxCreationKeys() { TxCreationKeys_free(self); }
+ TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
+ LDKTxCreationKeys* operator &() { return &self; }
+ LDKTxCreationKeys* operator ->() { return &self; }
+ const LDKTxCreationKeys* operator &() const { return &self; }
+ const LDKTxCreationKeys* operator ->() const { return &self; }
+};
+class ChannelPublicKeys {
+private:
+ LDKChannelPublicKeys self;
+public:
+ ChannelPublicKeys(const ChannelPublicKeys&) = delete;
+ ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
+ ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
+ operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
+ ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
+ 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:
};
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 BackgroundProcessor {
-private:
- LDKBackgroundProcessor self;
-public:
- BackgroundProcessor(const BackgroundProcessor&) = delete;
- BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
- BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
- operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
- ~BackgroundProcessor() { BackgroundProcessor_free(self); }
- BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
- LDKBackgroundProcessor* operator &() { return &self; }
- LDKBackgroundProcessor* operator ->() { return &self; }
- const LDKBackgroundProcessor* operator &() const { return &self; }
- const LDKBackgroundProcessor* operator ->() const { return &self; }
-};
-class GossipSync {
-private:
- LDKGossipSync self;
-public:
- GossipSync(const GossipSync&) = delete;
- GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
- GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
- operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
- ~GossipSync() { GossipSync_free(self); }
- GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
- LDKGossipSync* operator &() { return &self; }
- LDKGossipSync* operator ->() { return &self; }
- const LDKGossipSync* operator &() const { return &self; }
- const LDKGossipSync* operator ->() const { return &self; }
-};
-class RouteHop {
-private:
- LDKRouteHop self;
-public:
- RouteHop(const RouteHop&) = delete;
- RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
- RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
- operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
- ~RouteHop() { RouteHop_free(self); }
- RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
- LDKRouteHop* operator &() { return &self; }
- LDKRouteHop* operator ->() { return &self; }
- const LDKRouteHop* operator &() const { return &self; }
- const LDKRouteHop* operator ->() const { return &self; }
-};
-class Route {
-private:
- LDKRoute self;
-public:
- Route(const Route&) = delete;
- Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
- Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
- operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
- ~Route() { Route_free(self); }
- Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
- LDKRoute* operator &() { return &self; }
- LDKRoute* operator ->() { return &self; }
- const LDKRoute* operator &() const { return &self; }
- const LDKRoute* operator ->() const { return &self; }
-};
-class RouteParameters {
-private:
- LDKRouteParameters self;
-public:
- RouteParameters(const RouteParameters&) = delete;
- RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
- RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
- operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
- ~RouteParameters() { RouteParameters_free(self); }
- RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
- LDKRouteParameters* operator &() { return &self; }
- LDKRouteParameters* operator ->() { return &self; }
- const LDKRouteParameters* operator &() const { return &self; }
- const LDKRouteParameters* operator ->() const { return &self; }
-};
-class PaymentParameters {
-private:
- LDKPaymentParameters self;
-public:
- PaymentParameters(const PaymentParameters&) = delete;
- PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
- PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
- operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
- ~PaymentParameters() { PaymentParameters_free(self); }
- PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
- LDKPaymentParameters* operator &() { return &self; }
- LDKPaymentParameters* operator ->() { return &self; }
- const LDKPaymentParameters* operator &() const { return &self; }
- const LDKPaymentParameters* operator ->() const { return &self; }
+ 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 RouteHint {
+class Bolt12ParseError {
private:
- LDKRouteHint self;
+ LDKBolt12ParseError 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; }
+ 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 RouteHintHop {
+class Bolt12SemanticError {
private:
- LDKRouteHintHop self;
+ LDKBolt12SemanticError 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; }
+ 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:
const LDKBroadcasterInterface* operator &() const { return &self; }
const LDKBroadcasterInterface* operator ->() const { return &self; }
/**
- * Sends a transaction out to (hopefully) be mined.
+ * 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_transaction(struct LDKTransaction tx);
+ inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
};
class ConfirmationTarget {
private:
*/
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;
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;
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;
*/
inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
};
-class OnionMessageProvider {
+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:
- LDKOnionMessageProvider self;
+ LDKPayeePubKey self;
public:
- OnionMessageProvider(const OnionMessageProvider&) = delete;
- OnionMessageProvider(OnionMessageProvider&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageProvider)); }
- OnionMessageProvider(LDKOnionMessageProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageProvider)); }
- operator LDKOnionMessageProvider() && { LDKOnionMessageProvider res = self; memset(&self, 0, sizeof(LDKOnionMessageProvider)); return res; }
- ~OnionMessageProvider() { OnionMessageProvider_free(self); }
- OnionMessageProvider& operator=(OnionMessageProvider&& o) { OnionMessageProvider_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageProvider)); return *this; }
- LDKOnionMessageProvider* operator &() { return &self; }
- LDKOnionMessageProvider* operator ->() { return &self; }
- const LDKOnionMessageProvider* operator &() const { return &self; }
- const LDKOnionMessageProvider* operator ->() const { return &self; }
- /**
- * Gets 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);
+ 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 EventsProvider {
+class ExpiryTime {
private:
- LDKEventsProvider self;
+ LDKExpiryTime 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);
+ 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 EventHandler {
+class MinFinalCltvExpiryDelta {
private:
- LDKEventHandler self;
+ LDKMinFinalCltvExpiryDelta 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 void handle_event(const struct LDKEvent *NONNULL_PTR event);
+ 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 BestBlock {
+class Fallback {
private:
- LDKBestBlock self;
+ LDKFallback self;
public:
- BestBlock(const BestBlock&) = delete;
- BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
- BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
- operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
- ~BestBlock() { BestBlock_free(self); }
- BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
- LDKBestBlock* operator &() { return &self; }
- LDKBestBlock* operator ->() { return &self; }
- const LDKBestBlock* operator &() const { return &self; }
- const LDKBestBlock* operator ->() const { return &self; }
+ 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 AccessError {
+class Bolt11InvoiceSignature {
private:
- LDKAccessError self;
+ LDKBolt11InvoiceSignature self;
public:
- AccessError(const AccessError&) = delete;
- AccessError(AccessError&& o) : self(o.self) { memset(&o, 0, sizeof(AccessError)); }
- AccessError(LDKAccessError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccessError)); }
- operator LDKAccessError() && { LDKAccessError res = self; memset(&self, 0, sizeof(LDKAccessError)); return res; }
- AccessError& operator=(AccessError&& o) { self = o.self; memset(&o, 0, sizeof(AccessError)); return *this; }
- LDKAccessError* operator &() { return &self; }
- LDKAccessError* operator ->() { return &self; }
- const LDKAccessError* operator &() const { return &self; }
- const LDKAccessError* operator ->() const { return &self; }
+ 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 Access {
+class PrivateRoute {
private:
- LDKAccess self;
+ LDKPrivateRoute self;
public:
- Access(const Access&) = delete;
- Access(Access&& o) : self(o.self) { memset(&o, 0, sizeof(Access)); }
- Access(LDKAccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAccess)); }
- operator LDKAccess() && { LDKAccess res = self; memset(&self, 0, sizeof(LDKAccess)); return res; }
- ~Access() { Access_free(self); }
- Access& operator=(Access&& o) { Access_free(self); self = o.self; memset(&o, 0, sizeof(Access)); return *this; }
- LDKAccess* operator &() { return &self; }
- LDKAccess* operator ->() { return &self; }
- const LDKAccess* operator &() const { return &self; }
- const LDKAccess* operator ->() const { return &self; }
- /**
- * Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
- * Returns an error if `genesis_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::CResult_TxOutAccessErrorZ get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
+ 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 Listen {
+class CreationError {
private:
- LDKListen self;
+ LDKCreationError self;
public:
- Listen(const Listen&) = delete;
- Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
- Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
- operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
- ~Listen() { Listen_free(self); }
- Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
- LDKListen* operator &() { return &self; }
- LDKListen* operator ->() { return &self; }
- const LDKListen* operator &() const { return &self; }
- const LDKListen* operator ->() const { return &self; }
- /**
- * Notifies the listener that a block was added at the given height, with the transaction data
- * possibly filtered.
- */
- inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
- /**
- * Notifies the listener that a block was added at the given height.
- */
- inline void block_connected(struct LDKu8slice block, uint32_t height);
- /**
- * Notifies the listener that a block was removed at the given height.
- */
- inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
+ 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 Confirm {
+class Bolt11SemanticError {
private:
- LDKConfirm self;
+ LDKBolt11SemanticError self;
public:
- Confirm(const Confirm&) = delete;
- Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
- Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
- operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
- ~Confirm() { Confirm_free(self); }
- Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
- LDKConfirm* operator &() { return &self; }
- LDKConfirm* operator ->() { return &self; }
- const LDKConfirm* operator &() const { return &self; }
- const LDKConfirm* operator ->() const { return &self; }
- /**
- * Processes transactions confirmed in a block with a given header and height.
- *
- * Should be called for any transactions registered by [`Filter::register_tx`] or any
- * transactions spending an output registered by [`Filter::register_output`]. Such transactions
- * appearing in the same block do not need to be included in the same call; instead, multiple
- * calls with additional transactions may be made so long as they are made in [chain order].
- *
- * May be called before or after [`best_block_updated`] for the corresponding block. However,
- * in the event of a chain reorganization, it must not be called with a `header` that is no
- * longer in the chain as of the last call to [`best_block_updated`].
- *
- * [chain order]: Confirm#order
- * [`best_block_updated`]: Self::best_block_updated
- */
- inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
- /**
- * Processes a transaction that is no longer confirmed as result of a chain reorganization.
- *
- * Should be called for any transaction returned by [`get_relevant_txids`] if it has been
- * reorganized out of the best chain. Once called, the given transaction will not be returned
- * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
- *
- * [`get_relevant_txids`]: Self::get_relevant_txids
- * [`transactions_confirmed`]: Self::transactions_confirmed
- */
- inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
- /**
- * Processes an update to the best header connected at the given height.
- *
- * Should be called when a new header is available but may be skipped for intermediary blocks
- * if they become available at the same time.
- */
- inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
- /**
- * Returns transactions that should be monitored for reorganization out of the chain.
- *
- * Will include any transactions passed to [`transactions_confirmed`] that have insufficient
- * confirmations to be safe from a chain reorganization. Will not include any transactions
- * passed to [`transaction_unconfirmed`], unless later reconfirmed.
- *
- * May be called to determine the subset of transactions that must still be monitored for
- * reorganization. Will be idempotent between calls but may change as a result of calls to the
- * other interface methods. Thus, this is useful to determine which transactions may need to be
- * given to [`transaction_unconfirmed`].
- *
- * [`transactions_confirmed`]: Self::transactions_confirmed
- * [`transaction_unconfirmed`]: Self::transaction_unconfirmed
- */
- inline LDK::CVec_TxidZ get_relevant_txids();
+ 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 ChannelMonitorUpdateErr {
+class SignOrCreationError {
private:
- LDKChannelMonitorUpdateErr self;
+ LDKSignOrCreationError self;
public:
- ChannelMonitorUpdateErr(const ChannelMonitorUpdateErr&) = delete;
- ChannelMonitorUpdateErr(ChannelMonitorUpdateErr&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); }
- ChannelMonitorUpdateErr(LDKChannelMonitorUpdateErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateErr)); }
- operator LDKChannelMonitorUpdateErr() && { LDKChannelMonitorUpdateErr res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateErr)); return res; }
- ChannelMonitorUpdateErr& operator=(ChannelMonitorUpdateErr&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateErr)); return *this; }
- LDKChannelMonitorUpdateErr* operator &() { return &self; }
- LDKChannelMonitorUpdateErr* operator ->() { return &self; }
- const LDKChannelMonitorUpdateErr* operator &() const { return &self; }
- const LDKChannelMonitorUpdateErr* operator ->() const { return &self; }
+ 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 Watch {
+class OutPoint {
private:
- LDKWatch self;
+ LDKOutPoint self;
public:
- Watch(const Watch&) = delete;
- Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
- Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
- operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
- ~Watch() { Watch_free(self); }
- Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
- LDKWatch* operator &() { return &self; }
- LDKWatch* operator ->() { return &self; }
- const LDKWatch* operator &() const { return &self; }
- const LDKWatch* operator ->() const { return &self; }
- /**
- * Watches a channel identified by `funding_txo` using `monitor`.
- *
- * Implementations are responsible for watching the chain for the funding transaction along
- * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
- * calling [`block_connected`] and [`block_disconnected`] on the monitor.
- *
- * Note: this interface MUST error with `ChannelMonitorUpdateErr::PermanentFailure` if
- * the given `funding_txo` has previously been registered via `watch_channel`.
- *
- * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
- * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
- * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
- */
- inline LDK::CResult_NoneChannelMonitorUpdateErrZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
- /**
- * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
- *
- * Implementations must call [`update_monitor`] with the given update. See
- * [`ChannelMonitorUpdateErr`] for invariants around returning an error.
- *
- * [`update_monitor`]: channelmonitor::ChannelMonitor::update_monitor
- */
- inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update);
- /**
- * Returns any monitor events since the last call. Subsequent calls must only return new
- * events.
- *
- * Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
- * further events may be returned here until the [`ChannelMonitor`] has been fully persisted
- * to disk.
- *
- * For details on asynchronous [`ChannelMonitor`] updating and returning
- * [`MonitorEvent::UpdateCompleted`] here, see [`ChannelMonitorUpdateErr::TemporaryFailure`].
- */
- inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
+ 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 Filter {
+class BigSize {
private:
- LDKFilter self;
+ LDKBigSize self;
public:
- Filter(const Filter&) = delete;
- Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
- Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
- operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
- ~Filter() { Filter_free(self); }
- Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
- LDKFilter* operator &() { return &self; }
- LDKFilter* operator ->() { return &self; }
- const LDKFilter* operator &() const { return &self; }
- const LDKFilter* operator ->() const { return &self; }
- /**
- * Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
- * a spending condition.
- */
- inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
- /**
- * Registers interest in spends of a transaction output.
- *
- * Note that this method might be called during processing of a new block. You therefore need
- * to ensure that also dependent output spents within an already connected block are correctly
- * handled, e.g., by re-scanning the block in question whenever new outputs have been
- * registered mid-processing.
- */
- inline void register_output(struct LDKWatchedOutput output);
+ 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 WatchedOutput {
+class Hostname {
private:
- LDKWatchedOutput self;
+ LDKHostname self;
public:
- WatchedOutput(const WatchedOutput&) = delete;
- WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
- WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
- operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
- ~WatchedOutput() { WatchedOutput_free(self); }
- WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
- LDKWatchedOutput* operator &() { return &self; }
- LDKWatchedOutput* operator ->() { return &self; }
- const LDKWatchedOutput* operator &() const { return &self; }
- const LDKWatchedOutput* operator ->() const { return &self; }
+ 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 Score {
+class TransactionU16LenLimited {
private:
- LDKScore self;
+ LDKTransactionU16LenLimited self;
public:
- Score(const Score&) = delete;
- Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
- Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
- operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
- ~Score() { Score_free(self); }
- Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
- LDKScore* operator &() { return &self; }
- LDKScore* operator ->() { return &self; }
- const LDKScore* operator &() const { return &self; }
- const LDKScore* operator ->() const { return &self; }
- /**
- * Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
- * given channel in the direction from `source` to `target`.
- *
- * The channel's capacity (less any other MPP parts that are also being considered for use in
- * the same payment) is given by `capacity_msat`. It may be determined from various sources
- * such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
- * [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
- * Thus, implementations should be overflow-safe.
- */
- inline uint64_t channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage);
- /**
- * Handles updating channel penalties after failing to route through a channel.
- */
- inline void payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
+ 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; }
/**
- * Handles updating channel penalties after successfully routing along a path.
+ * 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 void payment_path_successful(struct LDKCVec_RouteHopZ path);
+ 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; }
/**
- * Handles updating channel penalties after a probe over the given path failed.
+ * Returns the type identifying the message payload.
*/
- inline void probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
+ inline uint16_t type_id();
/**
- * Handles updating channel penalties after a probe over the given path succeeded.
+ * Return a human-readable "debug" string describing this object
*/
- inline void probe_successful(struct LDKCVec_RouteHopZ path);
+ inline LDK::Str debug_str();
};
-class LockableScore {
-private:
- LDKLockableScore self;
-public:
- LockableScore(const LockableScore&) = delete;
- LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
- LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
- operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
- ~LockableScore() { LockableScore_free(self); }
- LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
- LDKLockableScore* operator &() { return &self; }
- LDKLockableScore* operator ->() { return &self; }
- const LDKLockableScore* operator &() const { return &self; }
- const LDKLockableScore* operator ->() const { return &self; }
+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 locked scorer.
+ * 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::Score lock();
+ inline LDK::UtxoResult get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id);
};
-class WriteableScore {
+class UtxoFuture {
private:
- LDKWriteableScore self;
+ LDKUtxoFuture self;
public:
- WriteableScore(const WriteableScore&) = delete;
- WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
- WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
- operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
- ~WriteableScore() { WriteableScore_free(self); }
- WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
- LDKWriteableScore* operator &() { return &self; }
- LDKWriteableScore* operator ->() { return &self; }
- const LDKWriteableScore* operator &() const { return &self; }
- const LDKWriteableScore* operator ->() const { return &self; }
+ 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 MultiThreadedLockableScore {
+class OnionMessenger {
private:
- LDKMultiThreadedLockableScore self;
+ LDKOnionMessenger self;
public:
- MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
- MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
- MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
- operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
- ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
- MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
- LDKMultiThreadedLockableScore* operator &() { return &self; }
- LDKMultiThreadedLockableScore* operator ->() { return &self; }
- const LDKMultiThreadedLockableScore* operator &() const { return &self; }
- const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
+ 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 MultiThreadedScoreLock {
-private:
- LDKMultiThreadedScoreLock self;
-public:
- MultiThreadedScoreLock(const MultiThreadedScoreLock&) = delete;
- MultiThreadedScoreLock(MultiThreadedScoreLock&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLock)); }
- MultiThreadedScoreLock(LDKMultiThreadedScoreLock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLock)); }
- operator LDKMultiThreadedScoreLock() && { LDKMultiThreadedScoreLock res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLock)); return res; }
- ~MultiThreadedScoreLock() { MultiThreadedScoreLock_free(self); }
- MultiThreadedScoreLock& operator=(MultiThreadedScoreLock&& o) { MultiThreadedScoreLock_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLock)); return *this; }
- LDKMultiThreadedScoreLock* operator &() { return &self; }
- LDKMultiThreadedScoreLock* operator ->() { return &self; }
- const LDKMultiThreadedScoreLock* operator &() const { return &self; }
- const LDKMultiThreadedScoreLock* 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 ChannelUsage {
+class Destination {
private:
- LDKChannelUsage self;
+ LDKDestination self;
public:
- ChannelUsage(const ChannelUsage&) = delete;
- ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
- ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
- operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
- ~ChannelUsage() { ChannelUsage_free(self); }
- ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
- LDKChannelUsage* operator &() { return &self; }
- LDKChannelUsage* operator ->() { return &self; }
- const LDKChannelUsage* operator &() const { return &self; }
- const LDKChannelUsage* operator ->() const { return &self; }
+ 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 FixedPenaltyScorer {
+class SendSuccess {
private:
- LDKFixedPenaltyScorer self;
+ LDKSendSuccess self;
public:
- FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
- FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
- FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
- operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
- ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
- FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
- LDKFixedPenaltyScorer* operator &() { return &self; }
- LDKFixedPenaltyScorer* operator ->() { return &self; }
- const LDKFixedPenaltyScorer* operator &() const { return &self; }
- const LDKFixedPenaltyScorer* operator ->() const { return &self; }
+ 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 ProbabilisticScorer {
+class SendError {
private:
- LDKProbabilisticScorer self;
+ LDKSendError self;
public:
- ProbabilisticScorer(const ProbabilisticScorer&) = delete;
- ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
- ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
- operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
- ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
- ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
- LDKProbabilisticScorer* operator &() { return &self; }
- LDKProbabilisticScorer* operator ->() { return &self; }
- const LDKProbabilisticScorer* operator &() const { return &self; }
- const LDKProbabilisticScorer* operator ->() const { return &self; }
+ 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 ProbabilisticScoringParameters {
+class CustomOnionMessageHandler {
private:
- LDKProbabilisticScoringParameters self;
+ LDKCustomOnionMessageHandler self;
public:
- ProbabilisticScoringParameters(const ProbabilisticScoringParameters&) = delete;
- ProbabilisticScoringParameters(ProbabilisticScoringParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringParameters)); }
- ProbabilisticScoringParameters(LDKProbabilisticScoringParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringParameters)); }
- operator LDKProbabilisticScoringParameters() && { LDKProbabilisticScoringParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringParameters)); return res; }
- ~ProbabilisticScoringParameters() { ProbabilisticScoringParameters_free(self); }
- ProbabilisticScoringParameters& operator=(ProbabilisticScoringParameters&& o) { ProbabilisticScoringParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringParameters)); return *this; }
- LDKProbabilisticScoringParameters* operator &() { return &self; }
- LDKProbabilisticScoringParameters* operator ->() { return &self; }
- const LDKProbabilisticScoringParameters* operator &() const { return &self; }
- const LDKProbabilisticScoringParameters* operator ->() const { return &self; }
+ 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:
const LDKChannelFeatures* operator &() const { return &self; }
const LDKChannelFeatures* operator ->() const { return &self; }
};
-class InvoiceFeatures {
-private:
- LDKInvoiceFeatures self;
-public:
- InvoiceFeatures(const InvoiceFeatures&) = delete;
- InvoiceFeatures(InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceFeatures)); }
- InvoiceFeatures(LDKInvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceFeatures)); }
- operator LDKInvoiceFeatures() && { LDKInvoiceFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceFeatures)); return res; }
- ~InvoiceFeatures() { InvoiceFeatures_free(self); }
- InvoiceFeatures& operator=(InvoiceFeatures&& o) { InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceFeatures)); return *this; }
- LDKInvoiceFeatures* operator &() { return &self; }
- LDKInvoiceFeatures* operator ->() { return &self; }
- const LDKInvoiceFeatures* operator &() const { return &self; }
- const LDKInvoiceFeatures* 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:
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 NodeId {
-private:
- LDKNodeId self;
-public:
- NodeId(const NodeId&) = delete;
- NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
- NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
- operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
- ~NodeId() { NodeId_free(self); }
- NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
- LDKNodeId* operator &() { return &self; }
- LDKNodeId* operator ->() { return &self; }
- const LDKNodeId* operator &() const { return &self; }
- const LDKNodeId* operator ->() const { return &self; }
-};
-class NetworkGraph {
-private:
- LDKNetworkGraph self;
-public:
- NetworkGraph(const NetworkGraph&) = delete;
- NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
- NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
- operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
- ~NetworkGraph() { NetworkGraph_free(self); }
- NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
- LDKNetworkGraph* operator &() { return &self; }
- LDKNetworkGraph* operator ->() { return &self; }
- const LDKNetworkGraph* operator &() const { return &self; }
- const LDKNetworkGraph* operator ->() const { return &self; }
-};
-class ReadOnlyNetworkGraph {
-private:
- LDKReadOnlyNetworkGraph self;
-public:
- ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
- ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
- ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
- operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
- ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
- ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
- LDKReadOnlyNetworkGraph* operator &() { return &self; }
- LDKReadOnlyNetworkGraph* operator ->() { return &self; }
- const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
- const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
-};
-class NetworkUpdate {
-private:
- LDKNetworkUpdate self;
-public:
- NetworkUpdate(const NetworkUpdate&) = delete;
- NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
- NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
- operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
- ~NetworkUpdate() { NetworkUpdate_free(self); }
- NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
- LDKNetworkUpdate* operator &() { return &self; }
- LDKNetworkUpdate* operator ->() { return &self; }
- const LDKNetworkUpdate* operator &() const { return &self; }
- const LDKNetworkUpdate* operator ->() const { return &self; }
-};
-class P2PGossipSync {
-private:
- LDKP2PGossipSync self;
-public:
- P2PGossipSync(const P2PGossipSync&) = delete;
- P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
- P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
- operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
- ~P2PGossipSync() { P2PGossipSync_free(self); }
- P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
- LDKP2PGossipSync* operator &() { return &self; }
- LDKP2PGossipSync* operator ->() { return &self; }
- const LDKP2PGossipSync* operator &() const { return &self; }
- const LDKP2PGossipSync* operator ->() const { return &self; }
-};
-class ChannelUpdateInfo {
-private:
- LDKChannelUpdateInfo self;
-public:
- ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
- ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
- ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
- operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
- ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
- ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
- LDKChannelUpdateInfo* operator &() { return &self; }
- LDKChannelUpdateInfo* operator ->() { return &self; }
- const LDKChannelUpdateInfo* operator &() const { return &self; }
- const LDKChannelUpdateInfo* operator ->() const { return &self; }
-};
-class ChannelInfo {
-private:
- LDKChannelInfo self;
-public:
- ChannelInfo(const ChannelInfo&) = delete;
- ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
- ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
- operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
- ~ChannelInfo() { ChannelInfo_free(self); }
- ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
- LDKChannelInfo* operator &() { return &self; }
- LDKChannelInfo* operator ->() { return &self; }
- const LDKChannelInfo* operator &() const { return &self; }
- const LDKChannelInfo* operator ->() const { return &self; }
-};
-class DirectedChannelInfo {
-private:
- LDKDirectedChannelInfo self;
-public:
- DirectedChannelInfo(const DirectedChannelInfo&) = delete;
- DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
- DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
- operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
- ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
- DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
- LDKDirectedChannelInfo* operator &() { return &self; }
- LDKDirectedChannelInfo* operator ->() { return &self; }
- const LDKDirectedChannelInfo* operator &() const { return &self; }
- const LDKDirectedChannelInfo* operator ->() const { return &self; }
-};
-class EffectiveCapacity {
-private:
- LDKEffectiveCapacity self;
-public:
- EffectiveCapacity(const EffectiveCapacity&) = delete;
- EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
- EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
- operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
- ~EffectiveCapacity() { EffectiveCapacity_free(self); }
- EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
- LDKEffectiveCapacity* operator &() { return &self; }
- LDKEffectiveCapacity* operator ->() { return &self; }
- const LDKEffectiveCapacity* operator &() const { return &self; }
- const LDKEffectiveCapacity* operator ->() const { return &self; }
-};
-class 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 NodeAnnouncementInfo {
-private:
- LDKNodeAnnouncementInfo self;
-public:
- NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
- NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
- NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
- operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
- ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
- NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
- LDKNodeAnnouncementInfo* operator &() { return &self; }
- LDKNodeAnnouncementInfo* operator ->() { return &self; }
- const LDKNodeAnnouncementInfo* operator &() const { return &self; }
- const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
-};
-class NodeAlias {
-private:
- LDKNodeAlias self;
-public:
- NodeAlias(const NodeAlias&) = delete;
- NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
- NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
- operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
- ~NodeAlias() { NodeAlias_free(self); }
- NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
- LDKNodeAlias* operator &() { return &self; }
- LDKNodeAlias* operator ->() { return &self; }
- const LDKNodeAlias* operator &() const { return &self; }
- const LDKNodeAlias* operator ->() const { return &self; }
-};
-class NodeInfo {
-private:
- LDKNodeInfo self;
-public:
- NodeInfo(const NodeInfo&) = delete;
- NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
- NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
- operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
- ~NodeInfo() { NodeInfo_free(self); }
- NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
- LDKNodeInfo* operator &() { return &self; }
- LDKNodeInfo* operator ->() { return &self; }
- const LDKNodeInfo* operator &() const { return &self; }
- const LDKNodeInfo* operator ->() const { return &self; }
-};
-class DelayedPaymentOutputDescriptor {
-private:
- LDKDelayedPaymentOutputDescriptor self;
-public:
- DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
- DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
- DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
- operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
- ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
- DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
- LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
- LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
- const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
- const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
-};
-class StaticPaymentOutputDescriptor {
-private:
- LDKStaticPaymentOutputDescriptor self;
-public:
- StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
- StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
- StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
- operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
- ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
- StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
- LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
- LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
- const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
- const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
-};
-class SpendableOutputDescriptor {
-private:
- LDKSpendableOutputDescriptor self;
-public:
- SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
- SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
- SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
- operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
- ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
- SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
- LDKSpendableOutputDescriptor* operator &() { return &self; }
- LDKSpendableOutputDescriptor* operator ->() { return &self; }
- const LDKSpendableOutputDescriptor* operator &() const { return &self; }
- const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
+ LDKChannelTypeFeatures* operator &() { return &self; }
+ LDKChannelTypeFeatures* operator ->() { return &self; }
+ const LDKChannelTypeFeatures* operator &() const { return &self; }
+ const LDKChannelTypeFeatures* operator ->() const { return &self; }
};
-class BaseSign {
-private:
- LDKBaseSign self;
-public:
- BaseSign(const BaseSign&) = delete;
- BaseSign(BaseSign&& o) : self(o.self) { memset(&o, 0, sizeof(BaseSign)); }
- BaseSign(LDKBaseSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBaseSign)); }
- operator LDKBaseSign() && { LDKBaseSign res = self; memset(&self, 0, sizeof(LDKBaseSign)); return res; }
- ~BaseSign() { BaseSign_free(self); }
- BaseSign& operator=(BaseSign&& o) { BaseSign_free(self); self = o.self; memset(&o, 0, sizeof(BaseSign)); return *this; }
- LDKBaseSign* operator &() { return &self; }
- LDKBaseSign* operator ->() { return &self; }
- const LDKBaseSign* operator &() const { return &self; }
- const LDKBaseSign* operator ->() const { return &self; }
- /**
- * Gets the per-commitment point for a specific commitment number
- *
- * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
- */
- inline LDKPublicKey get_per_commitment_point(uint64_t idx);
- /**
- * Gets the commitment secret for a specific commitment number as part of the revocation process
- *
- * An external signer implementation should error here if the commitment was already signed
- * and should refuse to sign it in the future.
- *
- * May be called more than once for the same index.
- *
- * Note that the commitment number starts at (1 << 48) - 1 and counts backwards.
- */
- inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
- /**
- * Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
- *
- * This is required in order for the signer to make sure that releasing a commitment
- * secret won't leave us without a broadcastable holder transaction.
- * Policy checks should be implemented in this function, including checking the amount
- * sent to us and checking the HTLCs.
- *
- * The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
- * A validating signer should ensure that an HTLC output is removed only when the matching
- * preimage is provided, or when the value to holder is restored.
- *
- * NOTE: all the relevant preimages will be provided, but there may also be additional
- * irrelevant or duplicate preimages.
- */
- inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages);
+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; }
/**
- * Gets an arbitrary identifier describing the set of keys which are provided back to you in
- * some SpendableOutputDescriptor types. This should be sufficient to identify this
- * Sign object uniquely and lookup or re-derive its keys.
- */
- inline LDKThirtyTwoBytes channel_keys_id();
- /**
- * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
- *
- * Note that if signing fails or is rejected, the channel will be force-closed.
- *
- * Policy checks should be implemented in this function, including checking the amount
- * sent to us and checking the HTLCs.
+ * Returns the node id of the forwarding node's channel counterparty with `short_channel_id`.
*
- * The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
- * A validating signer should ensure that an HTLC output is removed only when the matching
- * preimage is provided, or when the value to holder is restored.
+ * 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.
*
- * NOTE: all the relevant preimages will be provided, but there may also be additional
- * irrelevant or duplicate preimages.
- */
- inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages);
- /**
- * Validate the counterparty's revocation.
+ * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
*
- * This is required in order for the signer to make sure that the state has moved
- * forward and it is safe to sign the next counterparty commitment.
+ * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
- inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
+ 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; }
/**
- * Create a signatures for a holder's commitment transaction and its claiming HTLC transactions.
- * This will only ever be called with a non-revoked commitment_tx. This will be called with the
- * latest commitment_tx when we initiate a force-close.
- * This will be called with the previous latest, just to get claiming HTLC signatures, if we are
- * reacting to a ChannelMonitor replica that decided to broadcast before it had been updated to
- * the latest.
- * This may be called multiple times for the same transaction.
- *
- * An external signer implementation should check that the commitment has not been revoked.
+ * 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.
*
- * May return Err if key derivation fails. Callers, such as ChannelMonitor, will panic in such a case.
- */
- inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
- /**
- * Create a signature for the given input in a transaction spending an HTLC transaction output
- * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
+ * 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.
*
- * A justice transaction may claim multiple outputs at the same time if timelocks are
- * similar, but only a signature for the input at index `input` should be signed for here.
- * It may be called multiple times for same output(s) if a fee-bump is needed with regards
- * to an upcoming timelock expiration.
+ * 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`].
*
- * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+ * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
+ * and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
*
- * per_commitment_key is revocation secret which was provided by our counterparty when they
- * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
- * not allow the spending of any funds by itself (you need our holder revocation_secret to do
- * so).
+ * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+ * [`Writeable::write`]: crate::util::ser::Writeable::write
*/
- inline LDK::CResult_SignatureNoneZ sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]);
+ inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR monitor);
/**
- * Create a signature for the given input in a transaction spending a commitment transaction
- * HTLC output when our counterparty broadcasts an old state.
- *
- * A justice transaction may claim multiple outputs at the same time if timelocks are
- * similar, but only a signature for the input at index `input` should be signed for here.
- * It may be called multiple times for same output(s) if a fee-bump is needed with regards
- * to an upcoming timelock expiration.
- *
- * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
- *
- * per_commitment_key is revocation secret which was provided by our counterparty when they
- * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
- * not allow the spending of any funds by itself (you need our holder revocation_secret to do
- * so).
+ * Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
+ * update.
*
- * htlc holds HTLC elements (hash, timelock), thus changing the format of the witness script
- * (which is committed to in the BIP 143 signatures).
- */
- inline LDK::CResult_SignatureNoneZ sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
- /**
- * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
- * transaction, either offered or received.
+ * 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.
*
- * Such a transaction may claim multiples offered outputs at same time if we know the
- * preimage for each when we create it, but only the input at index `input` should be
- * signed for here. It may be called multiple times for same output(s) if a fee-bump is
- * needed with regards to an upcoming timelock expiration.
+ * 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.
*
- * Witness_script is either a offered or received script as defined in BOLT3 for HTLC
- * outputs.
+ * 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.
*
- * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+ * 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)`.
*
- * Per_commitment_point is the dynamic point corresponding to the channel state
- * detected onchain. It has been generated by our counterparty and is used to derive
- * channel state keys, which are then included in the witness script and committed to in the
- * BIP 143 signature.
- */
- inline LDK::CResult_SignatureNoneZ sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc);
- /**
- * Create a signature for a (proposed) closing transaction.
+ * 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`].
*
- * Note that, due to rounding, there may be one "missing" satoshi, and either party may have
- * chosen to forgo their output as dust.
- */
- inline LDK::CResult_SignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
- /**
- * Signs a channel announcement message with our funding key and our node secret key (aka
- * node_id or network_key), proving it comes from one of the channel participants.
+ * 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.
*
- * The first returned signature should be from our node secret key, the second from our
- * funding key.
+ * [`Writeable::write`]: crate::util::ser::Writeable::write
*
- * Note that if this fails or is rejected, the channel will not be publicly announced and
- * our counterparty may (though likely will not) close the channel on us for violating the
- * protocol.
+ * Note that monitor_update (or a relevant inner pointer) may be NULL or all-0s to represent None
*/
- inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
+ inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate monitor_update, const struct LDKChannelMonitor *NONNULL_PTR monitor);
/**
- * Set the counterparty static channel data, including basepoints,
- * counterparty_selected/holder_selected_contest_delay and funding outpoint.
- * This is done as soon as the funding outpoint is known. Since these are static channel data,
- * they MUST NOT be allowed to change to different values once set.
- *
- * channel_parameters.is_populated() MUST be true.
+ * Prevents the channel monitor from being loaded on startup.
*
- * We bind holder_selected_contest_delay late here for API convenience.
- *
- * Will be called before any signatures are applied.
+ * 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 ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
+ 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 Sign {
+class CResult_RetryDecodeErrorZ {
private:
- LDKSign self;
+ LDKCResult_RetryDecodeErrorZ self;
public:
- Sign(const Sign&) = delete;
- Sign(Sign&& o) : self(o.self) { memset(&o, 0, sizeof(Sign)); }
- Sign(LDKSign&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSign)); }
- operator LDKSign() && { LDKSign res = self; memset(&self, 0, sizeof(LDKSign)); return res; }
- ~Sign() { Sign_free(self); }
- Sign& operator=(Sign&& o) { Sign_free(self); self = o.self; memset(&o, 0, sizeof(Sign)); return *this; }
- LDKSign* operator &() { return &self; }
- LDKSign* operator ->() { return &self; }
- const LDKSign* operator &() const { return &self; }
- const LDKSign* operator ->() const { return &self; }
+ 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 Recipient {
+class CResult_BlindedForwardDecodeErrorZ {
private:
- LDKRecipient self;
+ LDKCResult_BlindedForwardDecodeErrorZ self;
public:
- Recipient(const Recipient&) = delete;
- Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
- Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
- operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
- Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
- LDKRecipient* operator &() { return &self; }
- LDKRecipient* operator ->() { return &self; }
- const LDKRecipient* operator &() const { return &self; }
- const LDKRecipient* operator ->() const { return &self; }
+ 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 KeysInterface {
+class CResult_ChannelInfoDecodeErrorZ {
private:
- LDKKeysInterface self;
+ LDKCResult_ChannelInfoDecodeErrorZ self;
public:
- KeysInterface(const KeysInterface&) = delete;
- KeysInterface(KeysInterface&& o) : self(o.self) { memset(&o, 0, sizeof(KeysInterface)); }
- KeysInterface(LDKKeysInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysInterface)); }
- operator LDKKeysInterface() && { LDKKeysInterface res = self; memset(&self, 0, sizeof(LDKKeysInterface)); return res; }
- ~KeysInterface() { KeysInterface_free(self); }
- KeysInterface& operator=(KeysInterface&& o) { KeysInterface_free(self); self = o.self; memset(&o, 0, sizeof(KeysInterface)); return *this; }
- LDKKeysInterface* operator &() { return &self; }
- LDKKeysInterface* operator ->() { return &self; }
- const LDKKeysInterface* operator &() const { return &self; }
- const LDKKeysInterface* operator ->() const { return &self; }
- /**
- * Get node secret key based on the provided [`Recipient`].
- *
- * The node_id/network_key is the public key that corresponds to this secret key.
- *
- * This method must return the same value each time it is called with a given `Recipient`
- * parameter.
- */
- inline LDK::CResult_SecretKeyNoneZ get_node_secret(enum LDKRecipient recipient);
- /**
- * Gets the ECDH shared secret of our [`node secret`] and `other_key`, multiplying by `tweak` if
- * one is provided. Note that this tweak can be applied to `other_key` instead of our node
- * secret, though this is less efficient.
- *
- * [`node secret`]: Self::get_node_secret
- */
- inline LDK::CResult_SharedSecretNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak);
- /**
- * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
- *
- * This method should return a different value each time it is called, to avoid linking
- * on-chain funds across channels as controlled to the same user.
- */
- inline LDK::CVec_u8Z get_destination_script();
- /**
- * Get a script pubkey which we will send funds to when closing a channel.
- *
- * This method should return a different value each time it is called, to avoid linking
- * on-chain funds across channels as controlled to the same user.
- */
- inline LDK::ShutdownScript get_shutdown_scriptpubkey();
- /**
- * Get a new set of Sign for per-channel secrets. These MUST be unique even if you
- * restarted with some stale data!
- *
- * This method must return a different value each time it is called.
- */
- inline LDK::Sign get_channel_signer(bool inbound, uint64_t channel_value_satoshis);
- /**
- * Gets a unique, cryptographically-secure, random 32 byte value. This is used for encrypting
- * onion packets and for temporary channel IDs. There is no requirement that these be
- * persisted anywhere, though they must be unique across restarts.
- *
- * This method must return a different value each time it is called.
- */
- inline LDKThirtyTwoBytes get_secure_random_bytes();
- /**
- * Reads a `Signer` for this `KeysInterface` from the given input stream.
- * This is only called during deserialization of other objects which contain
- * `Sign`-implementing objects (ie `ChannelMonitor`s and `ChannelManager`s).
- * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
- * contain no versioning scheme. You may wish to include your own version prefix and ensure
- * you've read all of the provided bytes to ensure no corruption occurred.
- */
- inline LDK::CResult_SignDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
- /**
- * Sign an invoice.
- * By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
- * this trait to parse the invoice and make sure they're signing what they expect, rather than
- * blindly signing the hash.
- * The hrp is ascii bytes, while the invoice data is base32.
- *
- * The secret key used to sign the invoice is dependent on the [`Recipient`].
- */
- inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient);
- /**
- * Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
- *
- * If the implementor of this trait supports [phantom node payments], then every node that is
- * intended to be included in the phantom invoice route hints must return the same value from
- * this method.
- *
- * This method must return the same value each time it is called.
- *
- * [phantom node payments]: PhantomKeysManager
- */
- inline LDKThirtyTwoBytes get_inbound_payment_key_material();
+ 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 InMemorySigner {
+class COption_PaymentContextZ {
private:
- LDKInMemorySigner self;
+ LDKCOption_PaymentContextZ self;
public:
- InMemorySigner(const InMemorySigner&) = delete;
- InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
- InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
- operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
- ~InMemorySigner() { InMemorySigner_free(self); }
- InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
- LDKInMemorySigner* operator &() { return &self; }
- LDKInMemorySigner* operator ->() { return &self; }
- const LDKInMemorySigner* operator &() const { return &self; }
- const LDKInMemorySigner* operator ->() const { return &self; }
+ 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 KeysManager {
+class COption_MaxDustHTLCExposureZ {
private:
- LDKKeysManager self;
+ LDKCOption_MaxDustHTLCExposureZ self;
public:
- KeysManager(const KeysManager&) = delete;
- KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
- KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
- operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
- ~KeysManager() { KeysManager_free(self); }
- KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
- LDKKeysManager* operator &() { return &self; }
- LDKKeysManager* operator ->() { return &self; }
- const LDKKeysManager* operator &() const { return &self; }
- const LDKKeysManager* operator ->() const { return &self; }
+ 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 PhantomKeysManager {
+class CResult_NoneSendErrorZ {
private:
- LDKPhantomKeysManager self;
+ LDKCResult_NoneSendErrorZ self;
public:
- PhantomKeysManager(const PhantomKeysManager&) = delete;
- PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
- PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
- operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
- ~PhantomKeysManager() { PhantomKeysManager_free(self); }
- PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
- LDKPhantomKeysManager* operator &() { return &self; }
- LDKPhantomKeysManager* operator ->() { return &self; }
- const LDKPhantomKeysManager* operator &() const { return &self; }
- const LDKPhantomKeysManager* operator ->() const { return &self; }
+ 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 FilesystemPersister {
+class CResult_CVec_u8ZPeerHandleErrorZ {
private:
- LDKFilesystemPersister self;
+ LDKCResult_CVec_u8ZPeerHandleErrorZ self;
public:
- FilesystemPersister(const FilesystemPersister&) = delete;
- FilesystemPersister(FilesystemPersister&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemPersister)); }
- FilesystemPersister(LDKFilesystemPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemPersister)); }
- operator LDKFilesystemPersister() && { LDKFilesystemPersister res = self; memset(&self, 0, sizeof(LDKFilesystemPersister)); return res; }
- ~FilesystemPersister() { FilesystemPersister_free(self); }
- FilesystemPersister& operator=(FilesystemPersister&& o) { FilesystemPersister_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemPersister)); return *this; }
- LDKFilesystemPersister* operator &() { return &self; }
- LDKFilesystemPersister* operator ->() { return &self; }
- const LDKFilesystemPersister* operator &() const { return &self; }
- const LDKFilesystemPersister* operator ->() const { return &self; }
+ 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 ChannelManager {
+class CResult_OnionPacketDecodeErrorZ {
private:
- LDKChannelManager self;
+ LDKCResult_OnionPacketDecodeErrorZ self;
public:
- ChannelManager(const ChannelManager&) = delete;
- ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
- ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
- operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
- ~ChannelManager() { ChannelManager_free(self); }
- ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
- LDKChannelManager* operator &() { return &self; }
- LDKChannelManager* operator ->() { return &self; }
- const LDKChannelManager* operator &() const { return &self; }
- const LDKChannelManager* operator ->() const { return &self; }
+ 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 ChainParameters {
+class COption_NetworkUpdateZ {
private:
- LDKChainParameters self;
+ LDKCOption_NetworkUpdateZ self;
public:
- ChainParameters(const ChainParameters&) = delete;
- ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
- ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
- operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
- ~ChainParameters() { ChainParameters_free(self); }
- ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
- LDKChainParameters* operator &() { return &self; }
- LDKChainParameters* operator ->() { return &self; }
- const LDKChainParameters* operator &() const { return &self; }
- const LDKChainParameters* operator ->() const { return &self; }
+ 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 CounterpartyForwardingInfo {
+class COption_u64Z {
private:
- LDKCounterpartyForwardingInfo self;
+ LDKCOption_u64Z 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; }
+ 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 ChannelCounterparty {
+class CResult_GossipTimestampFilterDecodeErrorZ {
private:
- LDKChannelCounterparty self;
+ LDKCResult_GossipTimestampFilterDecodeErrorZ 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; }
+ 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 ChannelDetails {
+class C2Tuple_OnionMessageContentsResponseInstructionZ {
private:
- LDKChannelDetails self;
+ LDKC2Tuple_OnionMessageContentsResponseInstructionZ 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; }
+ 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 PaymentSendFailure {
+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:
- LDKPaymentSendFailure self;
+ LDKCOption_FilterZ self;
public:
- PaymentSendFailure(const PaymentSendFailure&) = delete;
- PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
- PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
- operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
- ~PaymentSendFailure() { PaymentSendFailure_free(self); }
- PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
- LDKPaymentSendFailure* operator &() { return &self; }
- LDKPaymentSendFailure* operator ->() { return &self; }
- const LDKPaymentSendFailure* operator &() const { return &self; }
- const LDKPaymentSendFailure* operator ->() const { return &self; }
+ 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 PhantomRouteHints {
+class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
private:
- LDKPhantomRouteHints self;
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
public:
- PhantomRouteHints(const PhantomRouteHints&) = delete;
- PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
- PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
- operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
- ~PhantomRouteHints() { PhantomRouteHints_free(self); }
- PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
- LDKPhantomRouteHints* operator &() { return &self; }
- LDKPhantomRouteHints* operator ->() { return &self; }
- const LDKPhantomRouteHints* operator &() const { return &self; }
- const LDKPhantomRouteHints* operator ->() const { return &self; }
+ 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 ChannelManagerReadArgs {
+class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
private:
- LDKChannelManagerReadArgs self;
+ LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
public:
- ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
- ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
- ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
- operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
- ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
- ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
- LDKChannelManagerReadArgs* operator &() { return &self; }
- LDKChannelManagerReadArgs* operator ->() { return &self; }
- const LDKChannelManagerReadArgs* operator &() const { return &self; }
- const LDKChannelManagerReadArgs* operator ->() const { return &self; }
+ 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 ChannelHandshakeConfig {
+class CResult_COption_APIErrorZDecodeErrorZ {
private:
- LDKChannelHandshakeConfig self;
+ LDKCResult_COption_APIErrorZDecodeErrorZ self;
public:
- ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
- ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
- ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
- operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
- ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
- ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
- LDKChannelHandshakeConfig* operator &() { return &self; }
- LDKChannelHandshakeConfig* operator ->() { return &self; }
- const LDKChannelHandshakeConfig* operator &() const { return &self; }
- const LDKChannelHandshakeConfig* operator ->() const { return &self; }
+ 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 ChannelHandshakeLimits {
+class CVec_UpdateAddHTLCZ {
private:
- LDKChannelHandshakeLimits self;
+ LDKCVec_UpdateAddHTLCZ self;
public:
- ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
- ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
- ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
- operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
- ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
- ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
- LDKChannelHandshakeLimits* operator &() { return &self; }
- LDKChannelHandshakeLimits* operator ->() { return &self; }
- const LDKChannelHandshakeLimits* operator &() const { return &self; }
- const LDKChannelHandshakeLimits* operator ->() const { return &self; }
+ 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; }
};
-class ChannelConfig {
+class CResult_TxAbortDecodeErrorZ {
private:
- LDKChannelConfig self;
+ LDKCResult_TxAbortDecodeErrorZ self;
public:
- ChannelConfig(const ChannelConfig&) = delete;
- ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
- ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
- operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
- ~ChannelConfig() { ChannelConfig_free(self); }
- ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
- LDKChannelConfig* operator &() { return &self; }
- LDKChannelConfig* operator ->() { return &self; }
- const LDKChannelConfig* operator &() const { return &self; }
- const LDKChannelConfig* operator ->() const { return &self; }
+ CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
+ CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
+ CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
+ operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
+ ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
+ CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
+ LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
};
-class UserConfig {
+class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
private:
- LDKUserConfig self;
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
public:
- UserConfig(const UserConfig&) = delete;
- UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
- UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
- operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
- ~UserConfig() { UserConfig_free(self); }
- UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
- LDKUserConfig* operator &() { return &self; }
- LDKUserConfig* operator ->() { return &self; }
- const LDKUserConfig* operator &() const { return &self; }
- const LDKUserConfig* operator ->() const { return &self; }
+ CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
+ CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
+ CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
+ operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
+ ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
+ CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
};
-class APIError {
+class COption_u32Z {
private:
- LDKAPIError self;
+ LDKCOption_u32Z self;
public:
- APIError(const APIError&) = delete;
- APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
- APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
- operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
- ~APIError() { APIError_free(self); }
- APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
- LDKAPIError* operator &() { return &self; }
- LDKAPIError* operator ->() { return &self; }
- const LDKAPIError* operator &() const { return &self; }
- const LDKAPIError* operator ->() const { return &self; }
+ COption_u32Z(const COption_u32Z&) = delete;
+ COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
+ COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
+ operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
+ ~COption_u32Z() { COption_u32Z_free(self); }
+ COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
+ LDKCOption_u32Z* operator &() { return &self; }
+ LDKCOption_u32Z* operator ->() { return &self; }
+ const LDKCOption_u32Z* operator &() const { return &self; }
+ const LDKCOption_u32Z* operator ->() const { return &self; }
};
-class BigSize {
+class CResult_RecipientOnionFieldsNoneZ {
+private:
+ LDKCResult_RecipientOnionFieldsNoneZ self;
+public:
+ CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
+ CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
+ CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
+ operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
+ ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
+ CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
+ LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
+ LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
+ const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
+ const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
+};
+class C2Tuple__u1632_u1632Z {
+private:
+ LDKC2Tuple__u1632_u1632Z self;
+public:
+ C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
+ C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
+ C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
+ operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
+ ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
+ C2Tuple__u1632_u1632Z& operator=(C2Tuple__u1632_u1632Z&& o) { C2Tuple__u1632_u1632Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); return *this; }
+ LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
+ LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
+ const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
+ const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ {
+private:
+ LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ self;
+public:
+ CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ(const CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&) = delete;
+ CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); }
+ CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ(LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); }
+ operator LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ() && { LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); return res; }
+ ~CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ() { CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ_free(self); }
+ CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ& operator=(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ&& o) { CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ)); return *this; }
+ LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_OffersMessageMessageSendInstructionsZZ* operator ->() const { return &self; }
+};
+class C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ {
+private:
+ LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ self;
+public:
+ C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ(const C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&) = delete;
+ C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); }
+ C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ(LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); }
+ operator LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ() && { LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); return res; }
+ ~C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ() { C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ_free(self); }
+ C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ& operator=(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ&& o) { C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ)); return *this; }
+ LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator &() { return &self; }
+ LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator ->() { return &self; }
+ const LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator &() const { return &self; }
+ const LDKC2Tuple_AsyncPaymentsMessageMessageSendInstructionsZ* operator ->() const { return &self; }
+};
+class CResult_TransactionNoneZ {
private:
- LDKBigSize self;
+ LDKCResult_TransactionNoneZ 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; }
+ CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
+ CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
+ CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
+ operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
+ ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
+ CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
+ LDKCResult_TransactionNoneZ* operator &() { return &self; }
+ LDKCResult_TransactionNoneZ* operator ->() { return &self; }
+ const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
+ const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
};
-class Hostname {
+class CResult_CVec_StrZIOErrorZ {
+private:
+ LDKCResult_CVec_StrZIOErrorZ self;
+public:
+ CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
+ CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
+ CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
+ operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
+ ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
+ CResult_CVec_StrZIOErrorZ& operator=(CResult_CVec_StrZIOErrorZ&& o) { CResult_CVec_StrZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); return *this; }
+ LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
+ LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
+ const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
+ const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ {
+private:
+ LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ self;
+public:
+ CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(const CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&) = delete;
+ CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+ CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+ operator LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); return res; }
+ ~CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ() { CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); }
+ CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceWithExplicitSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class COption_ECDSASignatureZ {
+private:
+ LDKCOption_ECDSASignatureZ self;
+public:
+ COption_ECDSASignatureZ(const COption_ECDSASignatureZ&) = delete;
+ COption_ECDSASignatureZ(COption_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ECDSASignatureZ)); }
+ COption_ECDSASignatureZ(LDKCOption_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ECDSASignatureZ)); }
+ operator LDKCOption_ECDSASignatureZ() && { LDKCOption_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCOption_ECDSASignatureZ)); return res; }
+ ~COption_ECDSASignatureZ() { COption_ECDSASignatureZ_free(self); }
+ COption_ECDSASignatureZ& operator=(COption_ECDSASignatureZ&& o) { COption_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ECDSASignatureZ)); return *this; }
+ LDKCOption_ECDSASignatureZ* operator &() { return &self; }
+ LDKCOption_ECDSASignatureZ* operator ->() { return &self; }
+ const LDKCOption_ECDSASignatureZ* operator &() const { return &self; }
+ const LDKCOption_ECDSASignatureZ* operator ->() const { return &self; }
+};
+class CResult_ClosingSignedFeeRangeDecodeErrorZ {
private:
- LDKHostname self;
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ 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; }
+ CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
+ CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
+ CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
+ operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
+ ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
+ CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
};
-class OutPoint {
+class CResult_CommitmentSignedDecodeErrorZ {
private:
- LDKOutPoint self;
+ LDKCResult_CommitmentSignedDecodeErrorZ 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; }
+ CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
+ CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
+ CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
+ operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
+ ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
+ CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
+ LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
};
-class CustomMessageReader {
+class CResult_CommitmentTransactionDecodeErrorZ {
private:
- LDKCustomMessageReader self;
+ LDKCResult_CommitmentTransactionDecodeErrorZ 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);
+ CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
+ CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
+ CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
+ operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
+ ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
+ CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
+ LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
};
-class Type {
+class CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ {
private:
- LDKType self;
+ LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ 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();
+ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(const CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&) = delete;
+ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); }
+ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); }
+ operator LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ() && { LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); return res; }
+ ~CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ() { CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(self); }
+ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ& operator=(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ&& o) { CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ)); return *this; }
+ LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ* operator ->() const { return &self; }
};
-class InvoicePayer {
+class CResult_StfuDecodeErrorZ {
private:
- LDKInvoicePayer self;
+ LDKCResult_StfuDecodeErrorZ self;
public:
- InvoicePayer(const InvoicePayer&) = delete;
- InvoicePayer(InvoicePayer&& o) : self(o.self) { memset(&o, 0, sizeof(InvoicePayer)); }
- InvoicePayer(LDKInvoicePayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoicePayer)); }
- operator LDKInvoicePayer() && { LDKInvoicePayer res = self; memset(&self, 0, sizeof(LDKInvoicePayer)); return res; }
- ~InvoicePayer() { InvoicePayer_free(self); }
- InvoicePayer& operator=(InvoicePayer&& o) { InvoicePayer_free(self); self = o.self; memset(&o, 0, sizeof(InvoicePayer)); return *this; }
- LDKInvoicePayer* operator &() { return &self; }
- LDKInvoicePayer* operator ->() { return &self; }
- const LDKInvoicePayer* operator &() const { return &self; }
- const LDKInvoicePayer* operator ->() const { return &self; }
+ CResult_StfuDecodeErrorZ(const CResult_StfuDecodeErrorZ&) = delete;
+ CResult_StfuDecodeErrorZ(CResult_StfuDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); }
+ CResult_StfuDecodeErrorZ(LDKCResult_StfuDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); }
+ operator LDKCResult_StfuDecodeErrorZ() && { LDKCResult_StfuDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); return res; }
+ ~CResult_StfuDecodeErrorZ() { CResult_StfuDecodeErrorZ_free(self); }
+ CResult_StfuDecodeErrorZ& operator=(CResult_StfuDecodeErrorZ&& o) { CResult_StfuDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); return *this; }
+ LDKCResult_StfuDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_StfuDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_StfuDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_StfuDecodeErrorZ* operator ->() const { return &self; }
};
-class Payer {
+class CResult_OpenChannelDecodeErrorZ {
private:
- LDKPayer self;
+ LDKCResult_OpenChannelDecodeErrorZ self;
public:
- Payer(const Payer&) = delete;
- Payer(Payer&& o) : self(o.self) { memset(&o, 0, sizeof(Payer)); }
- Payer(LDKPayer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayer)); }
- operator LDKPayer() && { LDKPayer res = self; memset(&self, 0, sizeof(LDKPayer)); return res; }
- ~Payer() { Payer_free(self); }
- Payer& operator=(Payer&& o) { Payer_free(self); self = o.self; memset(&o, 0, sizeof(Payer)); return *this; }
- LDKPayer* operator &() { return &self; }
- LDKPayer* operator ->() { return &self; }
- const LDKPayer* operator &() const { return &self; }
- const LDKPayer* operator ->() const { return &self; }
- /**
- * Returns the payer's node id.
- */
- inline LDKPublicKey node_id();
- /**
- * Returns the payer's channels.
- */
- inline LDK::CVec_ChannelDetailsZ first_hops();
- /**
- * Sends a payment over the Lightning Network using the given [`Route`].
- *
- * Note that payment_secret (or a relevant inner pointer) may be NULL or all-0s to represent None
- */
- inline LDK::CResult_PaymentIdPaymentSendFailureZ send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret);
- /**
- * Sends a spontaneous payment over the Lightning Network using the given [`Route`].
- */
- inline LDK::CResult_PaymentIdPaymentSendFailureZ send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage);
- /**
- * Retries a failed payment path for the [`PaymentId`] using the given [`Route`].
- */
- inline LDK::CResult_NonePaymentSendFailureZ retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id);
- /**
- * Signals that no further retries for the given payment will occur.
- */
- inline void abandon_payment(struct LDKThirtyTwoBytes payment_id);
+ CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
+ CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
+ CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
+ operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
+ ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
+ CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
+ LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
};
-class Router {
+class CResult_ErrorMessageDecodeErrorZ {
private:
- LDKRouter self;
+ LDKCResult_ErrorMessageDecodeErrorZ self;
public:
- Router(const Router&) = delete;
- Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
- Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
- operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
- ~Router() { Router_free(self); }
- Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
- LDKRouter* operator &() { return &self; }
- LDKRouter* operator ->() { return &self; }
- const LDKRouter* operator &() const { return &self; }
- const LDKRouter* operator ->() const { return &self; }
- /**
- * Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
- *
- * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
- */
- inline LDK::CResult_RouteLightningErrorZ find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs);
- /**
- * Lets the router know that payment through a specific path has failed.
- */
- inline void notify_payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
- /**
- * Lets the router know that payment through a specific path was successful.
- */
- inline void notify_payment_path_successful(struct LDKCVec_RouteHopZ path);
- /**
- * Lets the router know that a payment probe was successful.
- */
- inline void notify_payment_probe_successful(struct LDKCVec_RouteHopZ path);
- /**
- * Lets the router know that a payment probe failed.
- */
- inline void notify_payment_probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id);
+ CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
+ CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
+ CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
+ operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
+ ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
+ CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
+ LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
};
-class Retry {
+class COption_APIErrorZ {
+private:
+ LDKCOption_APIErrorZ self;
+public:
+ COption_APIErrorZ(const COption_APIErrorZ&) = delete;
+ COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
+ COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
+ operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
+ ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
+ COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
+ LDKCOption_APIErrorZ* operator &() { return &self; }
+ LDKCOption_APIErrorZ* operator ->() { return &self; }
+ const LDKCOption_APIErrorZ* operator &() const { return &self; }
+ const LDKCOption_APIErrorZ* operator ->() const { return &self; }
+};
+class CVec_PeerDetailsZ {
+private:
+ LDKCVec_PeerDetailsZ self;
+public:
+ CVec_PeerDetailsZ(const CVec_PeerDetailsZ&) = delete;
+ CVec_PeerDetailsZ(CVec_PeerDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PeerDetailsZ)); }
+ CVec_PeerDetailsZ(LDKCVec_PeerDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PeerDetailsZ)); }
+ operator LDKCVec_PeerDetailsZ() && { LDKCVec_PeerDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_PeerDetailsZ)); return res; }
+ ~CVec_PeerDetailsZ() { CVec_PeerDetailsZ_free(self); }
+ CVec_PeerDetailsZ& operator=(CVec_PeerDetailsZ&& o) { CVec_PeerDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PeerDetailsZ)); return *this; }
+ LDKCVec_PeerDetailsZ* operator &() { return &self; }
+ LDKCVec_PeerDetailsZ* operator ->() { return &self; }
+ const LDKCVec_PeerDetailsZ* operator &() const { return &self; }
+ const LDKCVec_PeerDetailsZ* operator ->() const { return &self; }
+};
+class CResult_u64ShortChannelIdErrorZ {
+private:
+ LDKCResult_u64ShortChannelIdErrorZ self;
+public:
+ CResult_u64ShortChannelIdErrorZ(const CResult_u64ShortChannelIdErrorZ&) = delete;
+ CResult_u64ShortChannelIdErrorZ(CResult_u64ShortChannelIdErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u64ShortChannelIdErrorZ)); }
+ CResult_u64ShortChannelIdErrorZ(LDKCResult_u64ShortChannelIdErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u64ShortChannelIdErrorZ)); }
+ operator LDKCResult_u64ShortChannelIdErrorZ() && { LDKCResult_u64ShortChannelIdErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u64ShortChannelIdErrorZ)); return res; }
+ ~CResult_u64ShortChannelIdErrorZ() { CResult_u64ShortChannelIdErrorZ_free(self); }
+ CResult_u64ShortChannelIdErrorZ& operator=(CResult_u64ShortChannelIdErrorZ&& o) { CResult_u64ShortChannelIdErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u64ShortChannelIdErrorZ)); return *this; }
+ LDKCResult_u64ShortChannelIdErrorZ* operator &() { return &self; }
+ LDKCResult_u64ShortChannelIdErrorZ* operator ->() { return &self; }
+ const LDKCResult_u64ShortChannelIdErrorZ* operator &() const { return &self; }
+ const LDKCResult_u64ShortChannelIdErrorZ* operator ->() const { return &self; }
+};
+class CResult_QueryChannelRangeDecodeErrorZ {
private:
- LDKRetry self;
+ LDKCResult_QueryChannelRangeDecodeErrorZ self;
public:
- Retry(const Retry&) = delete;
- Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
- Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
- operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
- ~Retry() { Retry_free(self); }
- Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
- LDKRetry* operator &() { return &self; }
- LDKRetry* operator ->() { return &self; }
- const LDKRetry* operator &() const { return &self; }
- const LDKRetry* operator ->() const { return &self; }
+ CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
+ CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
+ CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
+ operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
+ ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
+ CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
+ LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
};
-class PaymentError {
+class CVec_InputZ {
private:
- LDKPaymentError self;
+ LDKCVec_InputZ self;
public:
- PaymentError(const PaymentError&) = delete;
- PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
- PaymentError(LDKPaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentError)); }
- operator LDKPaymentError() && { LDKPaymentError res = self; memset(&self, 0, sizeof(LDKPaymentError)); return res; }
- ~PaymentError() { PaymentError_free(self); }
- PaymentError& operator=(PaymentError&& o) { PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(PaymentError)); return *this; }
- LDKPaymentError* operator &() { return &self; }
- LDKPaymentError* operator ->() { return &self; }
- const LDKPaymentError* operator &() const { return &self; }
- const LDKPaymentError* operator ->() const { return &self; }
+ CVec_InputZ(const CVec_InputZ&) = delete;
+ CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
+ CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
+ operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
+ ~CVec_InputZ() { CVec_InputZ_free(self); }
+ CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
+ LDKCVec_InputZ* operator &() { return &self; }
+ LDKCVec_InputZ* operator ->() { return &self; }
+ const LDKCVec_InputZ* operator &() const { return &self; }
+ const LDKCVec_InputZ* operator ->() const { return &self; }
};
-class InFlightHtlcs {
+class CResult_ChannelFeaturesDecodeErrorZ {
private:
- LDKInFlightHtlcs self;
+ LDKCResult_ChannelFeaturesDecodeErrorZ self;
public:
- InFlightHtlcs(const InFlightHtlcs&) = delete;
- InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
- InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
- operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
- ~InFlightHtlcs() { InFlightHtlcs_free(self); }
- InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
- LDKInFlightHtlcs* operator &() { return &self; }
- LDKInFlightHtlcs* operator ->() { return &self; }
- const LDKInFlightHtlcs* operator &() const { return &self; }
- const LDKInFlightHtlcs* operator ->() const { return &self; }
+ CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
+ CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
+ CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
+ operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
+ ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
+ CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class ParseError {
+class CResult_ChannelReadyDecodeErrorZ {
private:
- LDKParseError self;
+ LDKCResult_ChannelReadyDecodeErrorZ self;
public:
- ParseError(const ParseError&) = delete;
- ParseError(ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseError)); }
- ParseError(LDKParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseError)); }
- operator LDKParseError() && { LDKParseError res = self; memset(&self, 0, sizeof(LDKParseError)); return res; }
- ~ParseError() { ParseError_free(self); }
- ParseError& operator=(ParseError&& o) { ParseError_free(self); self = o.self; memset(&o, 0, sizeof(ParseError)); return *this; }
- LDKParseError* operator &() { return &self; }
- LDKParseError* operator ->() { return &self; }
- const LDKParseError* operator &() const { return &self; }
- const LDKParseError* operator ->() const { return &self; }
+ CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
+ CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
+ CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
+ operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
+ ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
+ CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
};
-class ParseOrSemanticError {
+class CVec_TransactionZ {
private:
- LDKParseOrSemanticError self;
+ LDKCVec_TransactionZ 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; }
+ CVec_TransactionZ(const CVec_TransactionZ&) = delete;
+ CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
+ CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
+ operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
+ ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
+ CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
+ LDKCVec_TransactionZ* operator &() { return &self; }
+ LDKCVec_TransactionZ* operator ->() { return &self; }
+ const LDKCVec_TransactionZ* operator &() const { return &self; }
+ const LDKCVec_TransactionZ* operator ->() const { return &self; }
+};
+class CResult_UpdateFeeDecodeErrorZ {
+private:
+ LDKCResult_UpdateFeeDecodeErrorZ self;
+public:
+ CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
+ CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
+ CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
+ operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
+ ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
+ CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
+ LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
};
-class Invoice {
-private:
- LDKInvoice self;
-public:
- Invoice(const Invoice&) = delete;
- Invoice(Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Invoice)); }
- Invoice(LDKInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoice)); }
- operator LDKInvoice() && { LDKInvoice res = self; memset(&self, 0, sizeof(LDKInvoice)); return res; }
- ~Invoice() { Invoice_free(self); }
- Invoice& operator=(Invoice&& o) { Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Invoice)); return *this; }
- LDKInvoice* operator &() { return &self; }
- LDKInvoice* operator ->() { return &self; }
- const LDKInvoice* operator &() const { return &self; }
- const LDKInvoice* operator ->() const { return &self; }
-};
-class SignedRawInvoice {
-private:
- LDKSignedRawInvoice self;
-public:
- SignedRawInvoice(const SignedRawInvoice&) = delete;
- SignedRawInvoice(SignedRawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawInvoice)); }
- SignedRawInvoice(LDKSignedRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawInvoice)); }
- operator LDKSignedRawInvoice() && { LDKSignedRawInvoice res = self; memset(&self, 0, sizeof(LDKSignedRawInvoice)); return res; }
- ~SignedRawInvoice() { SignedRawInvoice_free(self); }
- SignedRawInvoice& operator=(SignedRawInvoice&& o) { SignedRawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawInvoice)); return *this; }
- LDKSignedRawInvoice* operator &() { return &self; }
- LDKSignedRawInvoice* operator ->() { return &self; }
- const LDKSignedRawInvoice* operator &() const { return &self; }
- const LDKSignedRawInvoice* operator ->() const { return &self; }
-};
-class RawInvoice {
-private:
- LDKRawInvoice self;
-public:
- RawInvoice(const RawInvoice&) = delete;
- RawInvoice(RawInvoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawInvoice)); }
- RawInvoice(LDKRawInvoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawInvoice)); }
- operator LDKRawInvoice() && { LDKRawInvoice res = self; memset(&self, 0, sizeof(LDKRawInvoice)); return res; }
- ~RawInvoice() { RawInvoice_free(self); }
- RawInvoice& operator=(RawInvoice&& o) { RawInvoice_free(self); self = o.self; memset(&o, 0, sizeof(RawInvoice)); return *this; }
- LDKRawInvoice* operator &() { return &self; }
- LDKRawInvoice* operator ->() { return &self; }
- const LDKRawInvoice* operator &() const { return &self; }
- const LDKRawInvoice* operator ->() const { return &self; }
+class CResult_NoneBolt11SemanticErrorZ {
+private:
+ LDKCResult_NoneBolt11SemanticErrorZ self;
+public:
+ CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
+ CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
+ CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
+ operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
+ ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
+ CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
+ LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_RevocationBasepointDecodeErrorZ {
+private:
+ LDKCResult_RevocationBasepointDecodeErrorZ self;
+public:
+ CResult_RevocationBasepointDecodeErrorZ(const CResult_RevocationBasepointDecodeErrorZ&) = delete;
+ CResult_RevocationBasepointDecodeErrorZ(CResult_RevocationBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); }
+ CResult_RevocationBasepointDecodeErrorZ(LDKCResult_RevocationBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); }
+ operator LDKCResult_RevocationBasepointDecodeErrorZ() && { LDKCResult_RevocationBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); return res; }
+ ~CResult_RevocationBasepointDecodeErrorZ() { CResult_RevocationBasepointDecodeErrorZ_free(self); }
+ CResult_RevocationBasepointDecodeErrorZ& operator=(CResult_RevocationBasepointDecodeErrorZ&& o) { CResult_RevocationBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); return *this; }
+ LDKCResult_RevocationBasepointDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RevocationBasepointDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_OnionMessageContentsZ {
+private:
+ LDKCOption_OnionMessageContentsZ self;
+public:
+ COption_OnionMessageContentsZ(const COption_OnionMessageContentsZ&) = delete;
+ COption_OnionMessageContentsZ(COption_OnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); }
+ COption_OnionMessageContentsZ(LDKCOption_OnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); }
+ operator LDKCOption_OnionMessageContentsZ() && { LDKCOption_OnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); return res; }
+ ~COption_OnionMessageContentsZ() { COption_OnionMessageContentsZ_free(self); }
+ COption_OnionMessageContentsZ& operator=(COption_OnionMessageContentsZ&& o) { COption_OnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); return *this; }
+ LDKCOption_OnionMessageContentsZ* operator &() { return &self; }
+ LDKCOption_OnionMessageContentsZ* operator ->() { return &self; }
+ const LDKCOption_OnionMessageContentsZ* operator &() const { return &self; }
+ const LDKCOption_OnionMessageContentsZ* operator ->() const { return &self; }
+};
+class CResult_NoneRetryableSendFailureZ {
+private:
+ LDKCResult_NoneRetryableSendFailureZ self;
+public:
+ CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
+ CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
+ CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
+ operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
+ ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
+ CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
+ LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
+ LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
+};
+class CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ {
+private:
+ LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ self;
+public:
+ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(const CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&) = delete;
+ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+ operator LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ() && { LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return res; }
+ ~CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ() { CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); }
+ CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ& operator=(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) { CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_RefundMaybeWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
};
-class RawDataPart {
+class CResult_NodeIdDecodeErrorZ {
private:
- LDKRawDataPart self;
+ LDKCResult_NodeIdDecodeErrorZ 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; }
+ CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
+ CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
+ CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
+ operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
+ ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
+ CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
+ LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
};
-class PositiveTimestamp {
+class CResult_boolLightningErrorZ {
private:
- LDKPositiveTimestamp self;
+ LDKCResult_boolLightningErrorZ 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; }
+ CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
+ CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
+ CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
+ operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
+ ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
+ CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
+ LDKCResult_boolLightningErrorZ* operator &() { return &self; }
+ LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
+ const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
+ const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
};
-class SiPrefix {
+class CResult_ChannelShutdownStateDecodeErrorZ {
private:
- LDKSiPrefix self;
+ LDKCResult_ChannelShutdownStateDecodeErrorZ 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; }
+ CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
+ CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
+ CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
+ operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
+ ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
+ CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_NodeAnnouncementInfoDecodeErrorZ {
+private:
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
+public:
+ CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
+ CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
+ CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
+ operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
+ ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
+ CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
};
-class Currency {
+class CResult_InvoiceRequestBolt12SemanticErrorZ {
private:
- LDKCurrency self;
+ LDKCResult_InvoiceRequestBolt12SemanticErrorZ 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; }
+ CResult_InvoiceRequestBolt12SemanticErrorZ(const CResult_InvoiceRequestBolt12SemanticErrorZ&) = delete;
+ CResult_InvoiceRequestBolt12SemanticErrorZ(CResult_InvoiceRequestBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestBolt12SemanticErrorZ)); }
+ CResult_InvoiceRequestBolt12SemanticErrorZ(LDKCResult_InvoiceRequestBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestBolt12SemanticErrorZ)); }
+ operator LDKCResult_InvoiceRequestBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestBolt12SemanticErrorZ)); return res; }
+ ~CResult_InvoiceRequestBolt12SemanticErrorZ() { CResult_InvoiceRequestBolt12SemanticErrorZ_free(self); }
+ CResult_InvoiceRequestBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceRequestBolt12SemanticErrorZ* operator ->() const { return &self; }
};
-class Sha256 {
+class CResult_COption_NetworkUpdateZDecodeErrorZ {
private:
- LDKSha256 self;
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ 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; }
+ CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
+ CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
+ CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
+ operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
+ ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
+ CResult_COption_NetworkUpdateZDecodeErrorZ& operator=(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
};
-class Description {
+class CVec_UpdateFailMalformedHTLCZ {
private:
- LDKDescription self;
+ LDKCVec_UpdateFailMalformedHTLCZ 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; }
+ CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
+ CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
+ CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
+ operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
+ ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
+ CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
+ LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
+ LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
+ const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
+ const LDKCVec_UpdateFailMalformedHTLCZ* 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 CResult_ShutdownScriptNoneZ {
+private:
+ LDKCResult_ShutdownScriptNoneZ self;
+public:
+ CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
+ CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
+ CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
+ operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
+ ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
+ CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
+ LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
+ LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
+ const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
+ const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
+};
+class CResult_PendingHTLCInfoInboundHTLCErrZ {
+private:
+ LDKCResult_PendingHTLCInfoInboundHTLCErrZ self;
+public:
+ CResult_PendingHTLCInfoInboundHTLCErrZ(const CResult_PendingHTLCInfoInboundHTLCErrZ&) = delete;
+ CResult_PendingHTLCInfoInboundHTLCErrZ(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); }
+ CResult_PendingHTLCInfoInboundHTLCErrZ(LDKCResult_PendingHTLCInfoInboundHTLCErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); }
+ operator LDKCResult_PendingHTLCInfoInboundHTLCErrZ() && { LDKCResult_PendingHTLCInfoInboundHTLCErrZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); return res; }
+ ~CResult_PendingHTLCInfoInboundHTLCErrZ() { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); }
+ CResult_PendingHTLCInfoInboundHTLCErrZ& operator=(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); return *this; }
+ LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() { return &self; }
+ LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() { return &self; }
+ const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() const { return &self; }
+ const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() const { return &self; }
+};
+class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ {
+private:
+ LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ self;
+public:
+ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(const CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&) = delete;
+ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
+ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
+ operator LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() && { LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return res; }
+ ~CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); }
+ CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ& operator=(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return *this; }
+ LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() { return &self; }
+ LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() { return &self; }
+ const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() const { return &self; }
+ const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() const { return &self; }
+};
+class CResult_PendingHTLCInfoDecodeErrorZ {
+private:
+ LDKCResult_PendingHTLCInfoDecodeErrorZ self;
+public:
+ CResult_PendingHTLCInfoDecodeErrorZ(const CResult_PendingHTLCInfoDecodeErrorZ&) = delete;
+ CResult_PendingHTLCInfoDecodeErrorZ(CResult_PendingHTLCInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); }
+ CResult_PendingHTLCInfoDecodeErrorZ(LDKCResult_PendingHTLCInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); }
+ operator LDKCResult_PendingHTLCInfoDecodeErrorZ() && { LDKCResult_PendingHTLCInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); return res; }
+ ~CResult_PendingHTLCInfoDecodeErrorZ() { CResult_PendingHTLCInfoDecodeErrorZ_free(self); }
+ CResult_PendingHTLCInfoDecodeErrorZ& operator=(CResult_PendingHTLCInfoDecodeErrorZ&& o) { CResult_PendingHTLCInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); return *this; }
+ LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SpliceInitDecodeErrorZ {
+private:
+ LDKCResult_SpliceInitDecodeErrorZ self;
+public:
+ CResult_SpliceInitDecodeErrorZ(const CResult_SpliceInitDecodeErrorZ&) = delete;
+ CResult_SpliceInitDecodeErrorZ(CResult_SpliceInitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceInitDecodeErrorZ)); }
+ CResult_SpliceInitDecodeErrorZ(LDKCResult_SpliceInitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceInitDecodeErrorZ)); }
+ operator LDKCResult_SpliceInitDecodeErrorZ() && { LDKCResult_SpliceInitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceInitDecodeErrorZ)); return res; }
+ ~CResult_SpliceInitDecodeErrorZ() { CResult_SpliceInitDecodeErrorZ_free(self); }
+ CResult_SpliceInitDecodeErrorZ& operator=(CResult_SpliceInitDecodeErrorZ&& o) { CResult_SpliceInitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceInitDecodeErrorZ)); return *this; }
+ LDKCResult_SpliceInitDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_SpliceInitDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_SpliceInitDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_SpliceInitDecodeErrorZ* operator ->() const { return &self; }
};
-class ExpiryTime {
+class CResult_HTLCOutputInCommitmentDecodeErrorZ {
private:
- LDKExpiryTime self;
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ 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; }
+ CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
+ CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
+ CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
+ operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
+ ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
+ CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
};
-class MinFinalCltvExpiry {
+class CVec_RouteHopZ {
private:
- LDKMinFinalCltvExpiry self;
+ LDKCVec_RouteHopZ self;
public:
- MinFinalCltvExpiry(const MinFinalCltvExpiry&) = delete;
- MinFinalCltvExpiry(MinFinalCltvExpiry&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiry)); }
- MinFinalCltvExpiry(LDKMinFinalCltvExpiry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiry)); }
- operator LDKMinFinalCltvExpiry() && { LDKMinFinalCltvExpiry res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiry)); return res; }
- ~MinFinalCltvExpiry() { MinFinalCltvExpiry_free(self); }
- MinFinalCltvExpiry& operator=(MinFinalCltvExpiry&& o) { MinFinalCltvExpiry_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiry)); return *this; }
- LDKMinFinalCltvExpiry* operator &() { return &self; }
- LDKMinFinalCltvExpiry* operator ->() { return &self; }
- const LDKMinFinalCltvExpiry* operator &() const { return &self; }
- const LDKMinFinalCltvExpiry* operator ->() const { return &self; }
+ CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
+ CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
+ CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
+ operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
+ ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
+ CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
+ LDKCVec_RouteHopZ* operator &() { return &self; }
+ LDKCVec_RouteHopZ* operator ->() { return &self; }
+ const LDKCVec_RouteHopZ* operator &() const { return &self; }
+ const LDKCVec_RouteHopZ* operator ->() const { return &self; }
};
-class Fallback {
+class CResult_ShutdownScriptInvalidShutdownScriptZ {
private:
- LDKFallback self;
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ 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; }
+ CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
+ CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
+ CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
+ operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
+ ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
+ CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
+ LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
+ const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
+ const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
};
-class InvoiceSignature {
+class CResult_CVec_UtxoZNoneZ {
private:
- LDKInvoiceSignature self;
+ LDKCResult_CVec_UtxoZNoneZ self;
public:
- InvoiceSignature(const InvoiceSignature&) = delete;
- InvoiceSignature(InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceSignature)); }
- InvoiceSignature(LDKInvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceSignature)); }
- operator LDKInvoiceSignature() && { LDKInvoiceSignature res = self; memset(&self, 0, sizeof(LDKInvoiceSignature)); return res; }
- ~InvoiceSignature() { InvoiceSignature_free(self); }
- InvoiceSignature& operator=(InvoiceSignature&& o) { InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceSignature)); return *this; }
- LDKInvoiceSignature* operator &() { return &self; }
- LDKInvoiceSignature* operator ->() { return &self; }
- const LDKInvoiceSignature* operator &() const { return &self; }
- const LDKInvoiceSignature* operator ->() const { return &self; }
+ CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
+ CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
+ CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
+ operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
+ ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
+ CResult_CVec_UtxoZNoneZ& operator=(CResult_CVec_UtxoZNoneZ&& o) { CResult_CVec_UtxoZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); return *this; }
+ LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
};
-class PrivateRoute {
+class CResult_CVec_u8ZIOErrorZ {
private:
- LDKPrivateRoute self;
+ LDKCResult_CVec_u8ZIOErrorZ 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; }
+ CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
+ CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
+ CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
+ operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
+ ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
+ CResult_CVec_u8ZIOErrorZ& operator=(CResult_CVec_u8ZIOErrorZ&& o) { CResult_CVec_u8ZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); return *this; }
+ LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
+ LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
+ const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
+ const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
};
-class CreationError {
+class COption_HTLCDestinationZ {
private:
- LDKCreationError self;
+ LDKCOption_HTLCDestinationZ 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; }
+ COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
+ COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
+ COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
+ operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
+ ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
+ COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
+ LDKCOption_HTLCDestinationZ* operator &() { return &self; }
+ LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
+ const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
+ const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
};
-class SemanticError {
+class CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ {
private:
- LDKSemanticError self;
+ LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ self;
public:
- SemanticError(const SemanticError&) = delete;
- SemanticError(SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(SemanticError)); }
- SemanticError(LDKSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSemanticError)); }
- operator LDKSemanticError() && { LDKSemanticError res = self; memset(&self, 0, sizeof(LDKSemanticError)); return res; }
- SemanticError& operator=(SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(SemanticError)); return *this; }
- LDKSemanticError* operator &() { return &self; }
- LDKSemanticError* operator ->() { return &self; }
- const LDKSemanticError* operator &() const { return &self; }
- const LDKSemanticError* operator ->() const { return &self; }
+ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(const CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&) = delete;
+ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); }
+ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); }
+ operator LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ() && { LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); return res; }
+ ~CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ() { CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(self); }
+ CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ& operator=(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ&& o) { CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_UnsignedBolt12InvoiceBolt12SemanticErrorZ* operator ->() const { return &self; }
};
-class SignOrCreationError {
+class CVec_ThirtyTwoBytesZ {
private:
- LDKSignOrCreationError self;
+ LDKCVec_ThirtyTwoBytesZ 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; }
+ CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
+ CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
+ CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
+ operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
+ ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
+ CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
+ LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
+ LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
+ const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
+ const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
};
-class ChannelMonitorUpdate {
+class CResult_ChannelMonitorUpdateStatusNoneZ {
private:
- LDKChannelMonitorUpdate self;
+ LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
public:
- ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
- ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
- ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
- operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
- ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
- ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
- LDKChannelMonitorUpdate* operator &() { return &self; }
- LDKChannelMonitorUpdate* operator ->() { return &self; }
- const LDKChannelMonitorUpdate* operator &() const { return &self; }
- const LDKChannelMonitorUpdate* operator ->() const { return &self; }
+ CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
+ CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
+ CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
+ operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
+ ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
+ CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
+ LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
+ LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
+ const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
+ const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
};
-class MonitorEvent {
+class CResult_ClosingSignedDecodeErrorZ {
private:
- LDKMonitorEvent self;
+ LDKCResult_ClosingSignedDecodeErrorZ self;
public:
- MonitorEvent(const MonitorEvent&) = delete;
- MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
- MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
- operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
- ~MonitorEvent() { MonitorEvent_free(self); }
- MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
- LDKMonitorEvent* operator &() { return &self; }
- LDKMonitorEvent* operator ->() { return &self; }
- const LDKMonitorEvent* operator &() const { return &self; }
- const LDKMonitorEvent* operator ->() const { return &self; }
+ CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
+ CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
+ CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
+ operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
+ ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
+ CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
+ LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
};
-class HTLCUpdate {
+class CVec_CResult_NoneAPIErrorZZ {
private:
- LDKHTLCUpdate self;
+ LDKCVec_CResult_NoneAPIErrorZZ self;
public:
- HTLCUpdate(const HTLCUpdate&) = delete;
- HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
- HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
- operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
- ~HTLCUpdate() { HTLCUpdate_free(self); }
- HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
- LDKHTLCUpdate* operator &() { return &self; }
- LDKHTLCUpdate* operator ->() { return &self; }
- const LDKHTLCUpdate* operator &() const { return &self; }
- const LDKHTLCUpdate* operator ->() const { return &self; }
+ CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
+ CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
+ CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
+ operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
+ ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
+ CVec_CResult_NoneAPIErrorZZ& operator=(CVec_CResult_NoneAPIErrorZZ&& o) { CVec_CResult_NoneAPIErrorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); return *this; }
+ LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
+ LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
+ const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
+ const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
};
-class Balance {
+class CResult_SchnorrSignatureNoneZ {
private:
- LDKBalance self;
+ LDKCResult_SchnorrSignatureNoneZ self;
public:
- Balance(const Balance&) = delete;
- Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
- Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
- operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
- ~Balance() { Balance_free(self); }
- Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
- LDKBalance* operator &() { return &self; }
- LDKBalance* operator ->() { return &self; }
- const LDKBalance* operator &() const { return &self; }
- const LDKBalance* operator ->() const { return &self; }
+ CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
+ CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
+ CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
+ operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
+ ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
+ CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
+ LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
+ LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
+ const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
+ const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
};
-class ChannelMonitor {
+class C2Tuple_ReleaseHeldHtlcResponseInstructionZ {
private:
- LDKChannelMonitor self;
+ LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ self;
public:
- ChannelMonitor(const ChannelMonitor&) = delete;
- ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
- ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
- operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
- ~ChannelMonitor() { ChannelMonitor_free(self); }
- ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
- LDKChannelMonitor* operator &() { return &self; }
- LDKChannelMonitor* operator ->() { return &self; }
- const LDKChannelMonitor* operator &() const { return &self; }
- const LDKChannelMonitor* operator ->() const { return &self; }
+ C2Tuple_ReleaseHeldHtlcResponseInstructionZ(const C2Tuple_ReleaseHeldHtlcResponseInstructionZ&) = delete;
+ C2Tuple_ReleaseHeldHtlcResponseInstructionZ(C2Tuple_ReleaseHeldHtlcResponseInstructionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ReleaseHeldHtlcResponseInstructionZ)); }
+ C2Tuple_ReleaseHeldHtlcResponseInstructionZ(LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ)); }
+ operator LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ() && { LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ)); return res; }
+ ~C2Tuple_ReleaseHeldHtlcResponseInstructionZ() { C2Tuple_ReleaseHeldHtlcResponseInstructionZ_free(self); }
+ C2Tuple_ReleaseHeldHtlcResponseInstructionZ& operator=(C2Tuple_ReleaseHeldHtlcResponseInstructionZ&& o) { C2Tuple_ReleaseHeldHtlcResponseInstructionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ReleaseHeldHtlcResponseInstructionZ)); return *this; }
+ LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator &() { return &self; }
+ LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator ->() { return &self; }
+ const LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator &() const { return &self; }
+ const LDKC2Tuple_ReleaseHeldHtlcResponseInstructionZ* operator ->() const { return &self; }
};
-class ExpandedKey {
+class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
private:
- LDKExpandedKey self;
+ LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
public:
- ExpandedKey(const ExpandedKey&) = delete;
- ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
- ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
- operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
- ~ExpandedKey() { ExpandedKey_free(self); }
- ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
- LDKExpandedKey* operator &() { return &self; }
- LDKExpandedKey* operator ->() { return &self; }
- const LDKExpandedKey* operator &() const { return &self; }
- const LDKExpandedKey* operator ->() const { return &self; }
+ CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
+ CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
+ CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
+ operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
+ ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
+ CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
+ LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
};
-class CustomMessageHandler {
+class CResult_HTLCDescriptorDecodeErrorZ {
private:
- LDKCustomMessageHandler self;
+ LDKCResult_HTLCDescriptorDecodeErrorZ self;
public:
- CustomMessageHandler(const CustomMessageHandler&) = delete;
- CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
- CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
- operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
- ~CustomMessageHandler() { CustomMessageHandler_free(self); }
- CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
- LDKCustomMessageHandler* operator &() { return &self; }
- LDKCustomMessageHandler* operator ->() { return &self; }
- const LDKCustomMessageHandler* operator &() const { return &self; }
- const LDKCustomMessageHandler* operator ->() const { return &self; }
- /**
- * Called with the message type that was received and the buffer to be read.
- * Can return a `MessageHandlingError` if the message could not be handled.
- */
- inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
- /**
- * Gets the list of pending messages which were generated by the custom message
- * handler, clearing the list in the process. The first tuple element must
- * correspond to the intended recipients node ids. If no connection to one of the
- * specified node does not exist, the message is simply not sent to it.
- */
- inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
+ CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
+ CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
+ CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
+ operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
+ ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
+ CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
+ LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
};
-class IgnoringMessageHandler {
+class CVec_RecentPaymentDetailsZ {
private:
- LDKIgnoringMessageHandler self;
+ LDKCVec_RecentPaymentDetailsZ self;
public:
- IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
- IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
- IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
- operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
- ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
- IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
- LDKIgnoringMessageHandler* operator &() { return &self; }
- LDKIgnoringMessageHandler* operator ->() { return &self; }
- const LDKIgnoringMessageHandler* operator &() const { return &self; }
- const LDKIgnoringMessageHandler* operator ->() const { return &self; }
+ CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
+ CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
+ CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
+ operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
+ ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
+ CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
+ LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
+ LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
+ const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
+ const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
};
-class ErroringMessageHandler {
+class CVec_RouteHintHopZ {
private:
- LDKErroringMessageHandler self;
+ LDKCVec_RouteHintHopZ self;
public:
- ErroringMessageHandler(const ErroringMessageHandler&) = delete;
- ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
- ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
- operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
- ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
- ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
- LDKErroringMessageHandler* operator &() { return &self; }
- LDKErroringMessageHandler* operator ->() { return &self; }
- const LDKErroringMessageHandler* operator &() const { return &self; }
- const LDKErroringMessageHandler* operator ->() const { return &self; }
+ CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
+ CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
+ CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
+ operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
+ ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
+ CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
+ LDKCVec_RouteHintHopZ* operator &() { return &self; }
+ LDKCVec_RouteHintHopZ* operator ->() { return &self; }
+ const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
+ const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
};
-class MessageHandler {
+class CResult_UntrustedStringDecodeErrorZ {
private:
- LDKMessageHandler self;
+ LDKCResult_UntrustedStringDecodeErrorZ self;
public:
- MessageHandler(const MessageHandler&) = delete;
- MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
- MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
- operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
- ~MessageHandler() { MessageHandler_free(self); }
- MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
- LDKMessageHandler* operator &() { return &self; }
- LDKMessageHandler* operator ->() { return &self; }
- const LDKMessageHandler* operator &() const { return &self; }
- const LDKMessageHandler* operator ->() const { return &self; }
+ CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
+ CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
+ CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
+ operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
+ ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
+ CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
+ LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
};
-class SocketDescriptor {
+class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ {
private:
- LDKSocketDescriptor self;
+ LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ self;
public:
- SocketDescriptor(const SocketDescriptor&) = delete;
- SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
- SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
- operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
- ~SocketDescriptor() { SocketDescriptor_free(self); }
- SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
- LDKSocketDescriptor* operator &() { return &self; }
- LDKSocketDescriptor* operator ->() { return &self; }
- const LDKSocketDescriptor* operator &() const { return &self; }
- const LDKSocketDescriptor* operator ->() const { return &self; }
- /**
- * Attempts to send some data from the given slice to the peer.
- *
- * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
- * Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
- * called and further write attempts may occur until that time.
- *
- * If the returned size is smaller than `data.len()`, a
- * [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
- * written. Additionally, until a `send_data` event completes fully, no further
- * [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
- * prevent denial-of-service issues, you should not read or buffer any data from the socket
- * until then.
- *
- * If a [`PeerManager::read_event`] call on this descriptor had previously returned true
- * (indicating that read events should be paused to prevent DoS in the send buffer),
- * `resume_read` may be set indicating that read events on this descriptor should resume. A
- * `resume_read` of false carries no meaning, and should not cause any action.
- */
- inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
- /**
- * Disconnect the socket pointed to by this SocketDescriptor.
- *
- * You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
- * call (doing so is a noop).
- */
- inline void disconnect_socket();
- /** Checks if two objects are equal given this object's this_arg pointer and another object. */
- inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
- /**
- * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
- * This is used, for example, for inclusion of this object in a hash map.
- */
- inline uint64_t hash();
+ CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(const CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&) = delete;
+ CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
+ CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
+ operator LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() && { LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return res; }
+ ~CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); }
+ CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ& operator=(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return *this; }
+ LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() { return &self; }
+ LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
+ const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
+ const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
};
-class PeerHandleError {
+class CResult_PaymentParametersDecodeErrorZ {
private:
- LDKPeerHandleError self;
+ LDKCResult_PaymentParametersDecodeErrorZ self;
public:
- PeerHandleError(const PeerHandleError&) = delete;
- PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
- PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
- operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
- ~PeerHandleError() { PeerHandleError_free(self); }
- PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
- LDKPeerHandleError* operator &() { return &self; }
- LDKPeerHandleError* operator ->() { return &self; }
- const LDKPeerHandleError* operator &() const { return &self; }
- const LDKPeerHandleError* operator ->() const { return &self; }
+ CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
+ CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
+ CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
+ operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
+ ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
+ CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
+ LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
};
-class PeerManager {
+class CResult_DelayedPaymentBasepointDecodeErrorZ {
+private:
+ LDKCResult_DelayedPaymentBasepointDecodeErrorZ self;
+public:
+ CResult_DelayedPaymentBasepointDecodeErrorZ(const CResult_DelayedPaymentBasepointDecodeErrorZ&) = delete;
+ CResult_DelayedPaymentBasepointDecodeErrorZ(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); }
+ CResult_DelayedPaymentBasepointDecodeErrorZ(LDKCResult_DelayedPaymentBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); }
+ operator LDKCResult_DelayedPaymentBasepointDecodeErrorZ() && { LDKCResult_DelayedPaymentBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); return res; }
+ ~CResult_DelayedPaymentBasepointDecodeErrorZ() { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); }
+ CResult_DelayedPaymentBasepointDecodeErrorZ& operator=(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); return *this; }
+ LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
+private:
+ LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
+public:
+ C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
+ C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
+ C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
+ operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
+ ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
+ C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
+ LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
+ LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
+};
+class COption_U128Z {
+private:
+ LDKCOption_U128Z self;
+public:
+ COption_U128Z(const COption_U128Z&) = delete;
+ COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
+ COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
+ operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
+ ~COption_U128Z() { COption_U128Z_free(self); }
+ COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
+ LDKCOption_U128Z* operator &() { return &self; }
+ LDKCOption_U128Z* operator ->() { return &self; }
+ const LDKCOption_U128Z* operator &() const { return &self; }
+ const LDKCOption_U128Z* operator ->() const { return &self; }
+};
+class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
+private:
+ LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
+public:
+ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
+ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
+ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
+ operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
+ ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
+ C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
+ LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
+ LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
+};
+class CVec_MessageForwardNodeZ {
+private:
+ LDKCVec_MessageForwardNodeZ self;
+public:
+ CVec_MessageForwardNodeZ(const CVec_MessageForwardNodeZ&) = delete;
+ CVec_MessageForwardNodeZ(CVec_MessageForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageForwardNodeZ)); }
+ CVec_MessageForwardNodeZ(LDKCVec_MessageForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageForwardNodeZ)); }
+ operator LDKCVec_MessageForwardNodeZ() && { LDKCVec_MessageForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageForwardNodeZ)); return res; }
+ ~CVec_MessageForwardNodeZ() { CVec_MessageForwardNodeZ_free(self); }
+ CVec_MessageForwardNodeZ& operator=(CVec_MessageForwardNodeZ&& o) { CVec_MessageForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageForwardNodeZ)); return *this; }
+ LDKCVec_MessageForwardNodeZ* operator &() { return &self; }
+ LDKCVec_MessageForwardNodeZ* operator ->() { return &self; }
+ const LDKCVec_MessageForwardNodeZ* operator &() const { return &self; }
+ const LDKCVec_MessageForwardNodeZ* operator ->() const { return &self; }
+};
+class CResult_TxAckRbfDecodeErrorZ {
+private:
+ LDKCResult_TxAckRbfDecodeErrorZ self;
+public:
+ CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
+ CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
+ CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
+ operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
+ ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
+ CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
+ LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
+private:
+ LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
+public:
+ CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
+ CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
+ CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
+ operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
+ ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
+ CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
+ LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
+};
+class COption_UtxoLookupZ {
+private:
+ LDKCOption_UtxoLookupZ self;
+public:
+ COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
+ COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
+ COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
+ operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
+ ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
+ COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
+ LDKCOption_UtxoLookupZ* operator &() { return &self; }
+ LDKCOption_UtxoLookupZ* operator ->() { return &self; }
+ const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
+ const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
+};
+class CResult__u832NoneZ {
+private:
+ LDKCResult__u832NoneZ self;
+public:
+ CResult__u832NoneZ(const CResult__u832NoneZ&) = delete;
+ CResult__u832NoneZ(CResult__u832NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832NoneZ)); }
+ CResult__u832NoneZ(LDKCResult__u832NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832NoneZ)); }
+ operator LDKCResult__u832NoneZ() && { LDKCResult__u832NoneZ res = self; memset(&self, 0, sizeof(LDKCResult__u832NoneZ)); return res; }
+ ~CResult__u832NoneZ() { CResult__u832NoneZ_free(self); }
+ CResult__u832NoneZ& operator=(CResult__u832NoneZ&& o) { CResult__u832NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832NoneZ)); return *this; }
+ LDKCResult__u832NoneZ* operator &() { return &self; }
+ LDKCResult__u832NoneZ* operator ->() { return &self; }
+ const LDKCResult__u832NoneZ* operator &() const { return &self; }
+ const LDKCResult__u832NoneZ* operator ->() const { return &self; }
+};
+class CResult_PongDecodeErrorZ {
private:
- LDKPeerManager self;
+ LDKCResult_PongDecodeErrorZ self;
public:
- PeerManager(const PeerManager&) = delete;
- PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
- PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
- operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
- ~PeerManager() { PeerManager_free(self); }
- PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
- LDKPeerManager* operator &() { return &self; }
- LDKPeerManager* operator ->() { return &self; }
- const LDKPeerManager* operator &() const { return &self; }
- const LDKPeerManager* operator ->() const { return &self; }
+ CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
+ CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
+ CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
+ operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
+ ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
+ CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
+ LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
};
-class OnionMessenger {
+class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
private:
- LDKOnionMessenger self;
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ 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; }
+ CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
+ CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
+ CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
+ operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
+ ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
+ CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
};
-class Destination {
+class CResult_ChannelIdAPIErrorZ {
+private:
+ LDKCResult_ChannelIdAPIErrorZ self;
+public:
+ CResult_ChannelIdAPIErrorZ(const CResult_ChannelIdAPIErrorZ&) = delete;
+ CResult_ChannelIdAPIErrorZ(CResult_ChannelIdAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelIdAPIErrorZ)); }
+ CResult_ChannelIdAPIErrorZ(LDKCResult_ChannelIdAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelIdAPIErrorZ)); }
+ operator LDKCResult_ChannelIdAPIErrorZ() && { LDKCResult_ChannelIdAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelIdAPIErrorZ)); return res; }
+ ~CResult_ChannelIdAPIErrorZ() { CResult_ChannelIdAPIErrorZ_free(self); }
+ CResult_ChannelIdAPIErrorZ& operator=(CResult_ChannelIdAPIErrorZ&& o) { CResult_ChannelIdAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelIdAPIErrorZ)); return *this; }
+ LDKCResult_ChannelIdAPIErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelIdAPIErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelIdAPIErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelIdAPIErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_u8ZNoneZ {
+private:
+ LDKCResult_CVec_u8ZNoneZ self;
+public:
+ CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
+ CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
+ CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
+ operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
+ ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
+ CResult_CVec_u8ZNoneZ& operator=(CResult_CVec_u8ZNoneZ&& o) { CResult_CVec_u8ZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); return *this; }
+ LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_ChannelIdPublicKeyZZ {
+private:
+ LDKCVec_C2Tuple_ChannelIdPublicKeyZZ self;
+public:
+ CVec_C2Tuple_ChannelIdPublicKeyZZ(const CVec_C2Tuple_ChannelIdPublicKeyZZ&) = delete;
+ CVec_C2Tuple_ChannelIdPublicKeyZZ(CVec_C2Tuple_ChannelIdPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ChannelIdPublicKeyZZ)); }
+ CVec_C2Tuple_ChannelIdPublicKeyZZ(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ)); }
+ operator LDKCVec_C2Tuple_ChannelIdPublicKeyZZ() && { LDKCVec_C2Tuple_ChannelIdPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ChannelIdPublicKeyZZ)); return res; }
+ ~CVec_C2Tuple_ChannelIdPublicKeyZZ() { CVec_C2Tuple_ChannelIdPublicKeyZZ_free(self); }
+ CVec_C2Tuple_ChannelIdPublicKeyZZ& operator=(CVec_C2Tuple_ChannelIdPublicKeyZZ&& o) { CVec_C2Tuple_ChannelIdPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ChannelIdPublicKeyZZ)); return *this; }
+ LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_ChannelIdPublicKeyZZ* operator ->() const { return &self; }
+};
+class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
+private:
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
+public:
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
+ operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
+ ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
+ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ& operator=(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return *this; }
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
+ LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
+};
+class CResult_ChannelTransactionParametersDecodeErrorZ {
private:
- LDKDestination self;
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ 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; }
+ CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
+ CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
+ CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
+ operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
+ ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
+ CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
};
-class SendError {
+class CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ {
private:
- LDKSendError self;
+ LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ 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; }
+ CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(const CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&) = delete;
+ CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); }
+ CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); }
+ operator LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); return res; }
+ ~CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ() { CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(self); }
+ CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceRequestWithDerivedPayerIdBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
};
-class RapidGossipSync {
+class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
private:
- LDKRapidGossipSync self;
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
public:
- RapidGossipSync(const RapidGossipSync&) = delete;
- RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
- RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
- operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
- ~RapidGossipSync() { RapidGossipSync_free(self); }
- RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
- LDKRapidGossipSync* operator &() { return &self; }
- LDKRapidGossipSync* operator ->() { return &self; }
- const LDKRapidGossipSync* operator &() const { return &self; }
- const LDKRapidGossipSync* operator ->() const { return &self; }
+ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
+ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
+ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
+ operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
+ ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
+ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
};
-class Persister {
+class CResult_InFlightHtlcsDecodeErrorZ {
private:
- LDKPersister self;
+ LDKCResult_InFlightHtlcsDecodeErrorZ self;
public:
- Persister(const Persister&) = delete;
- Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
- Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
- operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
- ~Persister() { Persister_free(self); }
- Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
- LDKPersister* operator &() { return &self; }
- LDKPersister* operator ->() { return &self; }
- const LDKPersister* operator &() const { return &self; }
- const LDKPersister* operator ->() const { return &self; }
- /**
- * Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
- */
- inline LDK::CResult_NoneErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
- /**
- * Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
- */
- inline LDK::CResult_NoneErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
- /**
- * Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
- */
- inline LDK::CResult_NoneErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
+ CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
+ CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
+ CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
+ operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
+ ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
+ CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
+ LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
};
-class DecodeError {
+class CResult_CommitmentSignedBatchDecodeErrorZ {
private:
- LDKDecodeError self;
+ LDKCResult_CommitmentSignedBatchDecodeErrorZ self;
public:
- DecodeError(const DecodeError&) = delete;
- DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
- DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
- operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
- ~DecodeError() { DecodeError_free(self); }
- DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
- LDKDecodeError* operator &() { return &self; }
- LDKDecodeError* operator ->() { return &self; }
- const LDKDecodeError* operator &() const { return &self; }
- const LDKDecodeError* operator ->() const { return &self; }
+ CResult_CommitmentSignedBatchDecodeErrorZ(const CResult_CommitmentSignedBatchDecodeErrorZ&) = delete;
+ CResult_CommitmentSignedBatchDecodeErrorZ(CResult_CommitmentSignedBatchDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedBatchDecodeErrorZ)); }
+ CResult_CommitmentSignedBatchDecodeErrorZ(LDKCResult_CommitmentSignedBatchDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedBatchDecodeErrorZ)); }
+ operator LDKCResult_CommitmentSignedBatchDecodeErrorZ() && { LDKCResult_CommitmentSignedBatchDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedBatchDecodeErrorZ)); return res; }
+ ~CResult_CommitmentSignedBatchDecodeErrorZ() { CResult_CommitmentSignedBatchDecodeErrorZ_free(self); }
+ CResult_CommitmentSignedBatchDecodeErrorZ& operator=(CResult_CommitmentSignedBatchDecodeErrorZ&& o) { CResult_CommitmentSignedBatchDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedBatchDecodeErrorZ)); return *this; }
+ LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_CommitmentSignedBatchDecodeErrorZ* operator ->() const { return &self; }
};
-class Init {
+class CResult_COption_HTLCDestinationZDecodeErrorZ {
private:
- LDKInit self;
+ LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
public:
- Init(const Init&) = delete;
- Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
- Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
- operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
- ~Init() { Init_free(self); }
- Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
- LDKInit* operator &() { return &self; }
- LDKInit* operator ->() { return &self; }
- const LDKInit* operator &() const { return &self; }
- const LDKInit* operator ->() const { return &self; }
+ CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
+ CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
+ CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
+ operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
+ ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
+ CResult_COption_HTLCDestinationZDecodeErrorZ& operator=(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
};
-class ErrorMessage {
+class CResult_Bolt12OfferContextDecodeErrorZ {
+private:
+ LDKCResult_Bolt12OfferContextDecodeErrorZ self;
+public:
+ CResult_Bolt12OfferContextDecodeErrorZ(const CResult_Bolt12OfferContextDecodeErrorZ&) = delete;
+ CResult_Bolt12OfferContextDecodeErrorZ(CResult_Bolt12OfferContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12OfferContextDecodeErrorZ)); }
+ CResult_Bolt12OfferContextDecodeErrorZ(LDKCResult_Bolt12OfferContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12OfferContextDecodeErrorZ)); }
+ operator LDKCResult_Bolt12OfferContextDecodeErrorZ() && { LDKCResult_Bolt12OfferContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12OfferContextDecodeErrorZ)); return res; }
+ ~CResult_Bolt12OfferContextDecodeErrorZ() { CResult_Bolt12OfferContextDecodeErrorZ_free(self); }
+ CResult_Bolt12OfferContextDecodeErrorZ& operator=(CResult_Bolt12OfferContextDecodeErrorZ&& o) { CResult_Bolt12OfferContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12OfferContextDecodeErrorZ)); return *this; }
+ LDKCResult_Bolt12OfferContextDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt12OfferContextDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt12OfferContextDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt12OfferContextDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ThirtyTwoBytesNoneZ {
+private:
+ LDKCResult_ThirtyTwoBytesNoneZ self;
+public:
+ CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
+ CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
+ CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
+ operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
+ ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
+ CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
+ LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
+ LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
+ const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
+ const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
+};
+class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
+private:
+ LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
+public:
+ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
+ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
+ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
+ operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
+ ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
+ C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ& operator=(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return *this; }
+ LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
+ LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
+ const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
+ const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
+};
+class CResult_SendSuccessSendErrorZ {
+private:
+ LDKCResult_SendSuccessSendErrorZ self;
+public:
+ CResult_SendSuccessSendErrorZ(const CResult_SendSuccessSendErrorZ&) = delete;
+ CResult_SendSuccessSendErrorZ(CResult_SendSuccessSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); }
+ CResult_SendSuccessSendErrorZ(LDKCResult_SendSuccessSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); }
+ operator LDKCResult_SendSuccessSendErrorZ() && { LDKCResult_SendSuccessSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); return res; }
+ ~CResult_SendSuccessSendErrorZ() { CResult_SendSuccessSendErrorZ_free(self); }
+ CResult_SendSuccessSendErrorZ& operator=(CResult_SendSuccessSendErrorZ&& o) { CResult_SendSuccessSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); return *this; }
+ LDKCResult_SendSuccessSendErrorZ* operator &() { return &self; }
+ LDKCResult_SendSuccessSendErrorZ* operator ->() { return &self; }
+ const LDKCResult_SendSuccessSendErrorZ* operator &() const { return &self; }
+ const LDKCResult_SendSuccessSendErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneReplayEventZ {
+private:
+ LDKCResult_NoneReplayEventZ self;
+public:
+ CResult_NoneReplayEventZ(const CResult_NoneReplayEventZ&) = delete;
+ CResult_NoneReplayEventZ(CResult_NoneReplayEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneReplayEventZ)); }
+ CResult_NoneReplayEventZ(LDKCResult_NoneReplayEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneReplayEventZ)); }
+ operator LDKCResult_NoneReplayEventZ() && { LDKCResult_NoneReplayEventZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneReplayEventZ)); return res; }
+ ~CResult_NoneReplayEventZ() { CResult_NoneReplayEventZ_free(self); }
+ CResult_NoneReplayEventZ& operator=(CResult_NoneReplayEventZ&& o) { CResult_NoneReplayEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneReplayEventZ)); return *this; }
+ LDKCResult_NoneReplayEventZ* operator &() { return &self; }
+ LDKCResult_NoneReplayEventZ* operator ->() { return &self; }
+ const LDKCResult_NoneReplayEventZ* operator &() const { return &self; }
+ const LDKCResult_NoneReplayEventZ* operator ->() const { return &self; }
+};
+class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ {
+private:
+ LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ self;
+public:
+ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(const C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&) = delete;
+ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
+ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
+ operator LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() && { LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return res; }
+ ~C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); }
+ C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ& operator=(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return *this; }
+ LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() { return &self; }
+ LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() { return &self; }
+ const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() const { return &self; }
+ const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() const { return &self; }
+};
+class CResult_BlindedHopDecodeErrorZ {
private:
- LDKErrorMessage self;
+ LDKCResult_BlindedHopDecodeErrorZ self;
public:
- ErrorMessage(const ErrorMessage&) = delete;
- ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
- ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
- operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
- ~ErrorMessage() { ErrorMessage_free(self); }
- ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
- LDKErrorMessage* operator &() { return &self; }
- LDKErrorMessage* operator ->() { return &self; }
- const LDKErrorMessage* operator &() const { return &self; }
- const LDKErrorMessage* operator ->() const { return &self; }
+ CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
+ CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
+ CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
+ operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
+ ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
+ CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
};
-class WarningMessage {
+class CResult_NoneLightningErrorZ {
private:
- LDKWarningMessage self;
+ LDKCResult_NoneLightningErrorZ self;
public:
- WarningMessage(const WarningMessage&) = delete;
- WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
- WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
- operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
- ~WarningMessage() { WarningMessage_free(self); }
- WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
- LDKWarningMessage* operator &() { return &self; }
- LDKWarningMessage* operator ->() { return &self; }
- const LDKWarningMessage* operator &() const { return &self; }
- const LDKWarningMessage* operator ->() const { return &self; }
+ CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
+ CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
+ CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
+ operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
+ ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
+ CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
+ LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
+ LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
+ const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
+ const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
};
-class Ping {
+class CResult_FixedPenaltyScorerDecodeErrorZ {
private:
- LDKPing self;
+ LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
public:
- Ping(const Ping&) = delete;
- Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
- Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
- operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
- ~Ping() { Ping_free(self); }
- Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
- LDKPing* operator &() { return &self; }
- LDKPing* operator ->() { return &self; }
- const LDKPing* operator &() const { return &self; }
- const LDKPing* operator ->() const { return &self; }
+ CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
+ CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
+ CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
+ operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
+ ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
+ CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
+ LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
};
-class Pong {
+class CResult_NonePeerHandleErrorZ {
private:
- LDKPong self;
+ LDKCResult_NonePeerHandleErrorZ self;
public:
- Pong(const Pong&) = delete;
- Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
- Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
- operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
- ~Pong() { Pong_free(self); }
- Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
- LDKPong* operator &() { return &self; }
- LDKPong* operator ->() { return &self; }
- const LDKPong* operator &() const { return &self; }
- const LDKPong* operator ->() const { return &self; }
+ CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
+ CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
+ CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
+ operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
+ ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
+ CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
+ LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
+ LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
+ const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
+ const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
};
-class OpenChannel {
+class CResult_TrustedCommitmentTransactionNoneZ {
private:
- LDKOpenChannel self;
+ LDKCResult_TrustedCommitmentTransactionNoneZ self;
public:
- OpenChannel(const OpenChannel&) = delete;
- OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
- OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
- operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
- ~OpenChannel() { OpenChannel_free(self); }
- OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
- LDKOpenChannel* operator &() { return &self; }
- LDKOpenChannel* operator ->() { return &self; }
- const LDKOpenChannel* operator &() const { return &self; }
- const LDKOpenChannel* operator ->() const { return &self; }
+ CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
+ CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
+ CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
+ operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
+ ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
+ CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
+ LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
+ LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
+ const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
+ const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
};
-class AcceptChannel {
+class CResult_FinalOnionHopDataDecodeErrorZ {
private:
- LDKAcceptChannel self;
+ LDKCResult_FinalOnionHopDataDecodeErrorZ self;
public:
- AcceptChannel(const AcceptChannel&) = delete;
- AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
- AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
- operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
- ~AcceptChannel() { AcceptChannel_free(self); }
- AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
- LDKAcceptChannel* operator &() { return &self; }
- LDKAcceptChannel* operator ->() { return &self; }
- const LDKAcceptChannel* operator &() const { return &self; }
- const LDKAcceptChannel* operator ->() const { return &self; }
+ CResult_FinalOnionHopDataDecodeErrorZ(const CResult_FinalOnionHopDataDecodeErrorZ&) = delete;
+ CResult_FinalOnionHopDataDecodeErrorZ(CResult_FinalOnionHopDataDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); }
+ CResult_FinalOnionHopDataDecodeErrorZ(LDKCResult_FinalOnionHopDataDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); }
+ operator LDKCResult_FinalOnionHopDataDecodeErrorZ() && { LDKCResult_FinalOnionHopDataDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); return res; }
+ ~CResult_FinalOnionHopDataDecodeErrorZ() { CResult_FinalOnionHopDataDecodeErrorZ_free(self); }
+ CResult_FinalOnionHopDataDecodeErrorZ& operator=(CResult_FinalOnionHopDataDecodeErrorZ&& o) { CResult_FinalOnionHopDataDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); return *this; }
+ LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_EventZDecodeErrorZ {
+private:
+ LDKCResult_COption_EventZDecodeErrorZ self;
+public:
+ CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
+ CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
+ CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
+ operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
+ ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
+ CResult_COption_EventZDecodeErrorZ& operator=(CResult_COption_EventZDecodeErrorZ&& o) { CResult_COption_EventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_SocketAddressZ {
+private:
+ LDKCOption_SocketAddressZ self;
+public:
+ COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
+ COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
+ COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
+ operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
+ ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
+ COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
+ LDKCOption_SocketAddressZ* operator &() { return &self; }
+ LDKCOption_SocketAddressZ* operator ->() { return &self; }
+ const LDKCOption_SocketAddressZ* operator &() const { return &self; }
+ const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
};
-class FundingCreated {
+class CResult_COption_MonitorEventZDecodeErrorZ {
private:
- LDKFundingCreated self;
+ LDKCResult_COption_MonitorEventZDecodeErrorZ self;
public:
- FundingCreated(const FundingCreated&) = delete;
- FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
- FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
- operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
- ~FundingCreated() { FundingCreated_free(self); }
- FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
- LDKFundingCreated* operator &() { return &self; }
- LDKFundingCreated* operator ->() { return &self; }
- const LDKFundingCreated* operator &() const { return &self; }
- const LDKFundingCreated* operator ->() const { return &self; }
+ CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
+ CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
+ CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
+ operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
+ ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
+ CResult_COption_MonitorEventZDecodeErrorZ& operator=(CResult_COption_MonitorEventZDecodeErrorZ&& o) { CResult_COption_MonitorEventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
};
-class FundingSigned {
+class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
private:
- LDKFundingSigned self;
+ LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
public:
- FundingSigned(const FundingSigned&) = delete;
- FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
- FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
- operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
- ~FundingSigned() { FundingSigned_free(self); }
- FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
- LDKFundingSigned* operator &() { return &self; }
- LDKFundingSigned* operator ->() { return &self; }
- const LDKFundingSigned* operator &() const { return &self; }
- const LDKFundingSigned* operator ->() const { return &self; }
+ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
+ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
+ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
+ operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
+ ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
+ COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ& operator=(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return *this; }
+ LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
+ LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
+ const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
+ const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
};
-class ChannelReady {
+class CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ {
private:
- LDKChannelReady self;
+ LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ self;
public:
- ChannelReady(const ChannelReady&) = delete;
- ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
- ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
- operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
- ~ChannelReady() { ChannelReady_free(self); }
- ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
- LDKChannelReady* operator &() { return &self; }
- LDKChannelReady* operator ->() { return &self; }
- const LDKChannelReady* operator &() const { return &self; }
- const LDKChannelReady* operator ->() const { return &self; }
+ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ(const CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&) = delete;
+ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); }
+ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); }
+ operator LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ() && { LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); return res; }
+ ~CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ() { CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(self); }
+ CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ& operator=(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ&& o) { CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_OutboundHTLCStateDetailsZDecodeErrorZ* operator ->() const { return &self; }
};
-class Shutdown {
+class CResult_RoutingFeesDecodeErrorZ {
private:
- LDKShutdown self;
+ LDKCResult_RoutingFeesDecodeErrorZ self;
public:
- Shutdown(const Shutdown&) = delete;
- Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
- Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
- operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
- ~Shutdown() { Shutdown_free(self); }
- Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
- LDKShutdown* operator &() { return &self; }
- LDKShutdown* operator ->() { return &self; }
- const LDKShutdown* operator &() const { return &self; }
- const LDKShutdown* operator ->() const { return &self; }
+ CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
+ CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
+ CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
+ operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
+ ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
+ CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
+ LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
};
-class ClosingSignedFeeRange {
+class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
private:
- LDKClosingSignedFeeRange self;
+ LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
public:
- ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
- ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
- ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
- operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
- ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
- ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
- LDKClosingSignedFeeRange* operator &() { return &self; }
- LDKClosingSignedFeeRange* operator ->() { return &self; }
- const LDKClosingSignedFeeRange* operator &() const { return &self; }
- const LDKClosingSignedFeeRange* operator ->() const { return &self; }
+ CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
+ CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); }
+ CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); }
+ operator LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); return res; }
+ ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
+ CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ)); return *this; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
};
-class ClosingSigned {
+class CResult_DescriptionCreationErrorZ {
private:
- LDKClosingSigned self;
+ LDKCResult_DescriptionCreationErrorZ self;
public:
- ClosingSigned(const ClosingSigned&) = delete;
- ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
- ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
- operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
- ~ClosingSigned() { ClosingSigned_free(self); }
- ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
- LDKClosingSigned* operator &() { return &self; }
- LDKClosingSigned* operator ->() { return &self; }
- const LDKClosingSigned* operator &() const { return &self; }
- const LDKClosingSigned* operator ->() const { return &self; }
+ CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
+ CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
+ CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
+ operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
+ ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
+ CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
+ LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
+ LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
+ const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
+ const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
};
-class UpdateAddHTLC {
+class CResult_PaymentRelayDecodeErrorZ {
private:
- LDKUpdateAddHTLC self;
+ LDKCResult_PaymentRelayDecodeErrorZ self;
public:
- UpdateAddHTLC(const UpdateAddHTLC&) = delete;
- UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
- UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
- operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
- ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
- UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
- LDKUpdateAddHTLC* operator &() { return &self; }
- LDKUpdateAddHTLC* operator ->() { return &self; }
- const LDKUpdateAddHTLC* operator &() const { return &self; }
- const LDKUpdateAddHTLC* operator ->() const { return &self; }
+ CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
+ CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
+ CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
+ operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
+ ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
+ CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
+ LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
};
-class OnionMessage {
+class CResult_QueryShortChannelIdsDecodeErrorZ {
private:
- LDKOnionMessage self;
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
public:
- OnionMessage(const OnionMessage&) = delete;
- OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
- OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
- operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
- ~OnionMessage() { OnionMessage_free(self); }
- OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
- LDKOnionMessage* operator &() { return &self; }
- LDKOnionMessage* operator ->() { return &self; }
- const LDKOnionMessage* operator &() const { return &self; }
- const LDKOnionMessage* operator ->() const { return &self; }
+ CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
+ CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
+ CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
+ operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
+ ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
+ CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
};
-class UpdateFulfillHTLC {
+class CResult_VerifiedInvoiceRequestNoneZ {
private:
- LDKUpdateFulfillHTLC self;
+ LDKCResult_VerifiedInvoiceRequestNoneZ self;
public:
- UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
- UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
- UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
- operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
- ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
- UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
- LDKUpdateFulfillHTLC* operator &() { return &self; }
- LDKUpdateFulfillHTLC* operator ->() { return &self; }
- const LDKUpdateFulfillHTLC* operator &() const { return &self; }
- const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
+ CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
+ CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
+ CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
+ operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
+ ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
+ CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
+ LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
+ LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
+ const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
+ const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
};
-class UpdateFailHTLC {
+class CResult_UpdateAddHTLCDecodeErrorZ {
private:
- LDKUpdateFailHTLC self;
+ LDKCResult_UpdateAddHTLCDecodeErrorZ self;
public:
- UpdateFailHTLC(const UpdateFailHTLC&) = delete;
- UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
- UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
- operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
- ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
- UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
- LDKUpdateFailHTLC* operator &() { return &self; }
- LDKUpdateFailHTLC* operator ->() { return &self; }
- const LDKUpdateFailHTLC* operator &() const { return &self; }
- const LDKUpdateFailHTLC* operator ->() const { return &self; }
+ CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
+ CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
+ CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
+ operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
+ ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
+ CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
};
-class UpdateFailMalformedHTLC {
+class COption_OutboundHTLCStateDetailsZ {
private:
- LDKUpdateFailMalformedHTLC self;
+ LDKCOption_OutboundHTLCStateDetailsZ self;
public:
- UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
- UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
- UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
- operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
- ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
- UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
- LDKUpdateFailMalformedHTLC* operator &() { return &self; }
- LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
- const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
- const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
+ COption_OutboundHTLCStateDetailsZ(const COption_OutboundHTLCStateDetailsZ&) = delete;
+ COption_OutboundHTLCStateDetailsZ(COption_OutboundHTLCStateDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OutboundHTLCStateDetailsZ)); }
+ COption_OutboundHTLCStateDetailsZ(LDKCOption_OutboundHTLCStateDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OutboundHTLCStateDetailsZ)); }
+ operator LDKCOption_OutboundHTLCStateDetailsZ() && { LDKCOption_OutboundHTLCStateDetailsZ res = self; memset(&self, 0, sizeof(LDKCOption_OutboundHTLCStateDetailsZ)); return res; }
+ ~COption_OutboundHTLCStateDetailsZ() { COption_OutboundHTLCStateDetailsZ_free(self); }
+ COption_OutboundHTLCStateDetailsZ& operator=(COption_OutboundHTLCStateDetailsZ&& o) { COption_OutboundHTLCStateDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OutboundHTLCStateDetailsZ)); return *this; }
+ LDKCOption_OutboundHTLCStateDetailsZ* operator &() { return &self; }
+ LDKCOption_OutboundHTLCStateDetailsZ* operator ->() { return &self; }
+ const LDKCOption_OutboundHTLCStateDetailsZ* operator &() const { return &self; }
+ const LDKCOption_OutboundHTLCStateDetailsZ* operator ->() const { return &self; }
};
-class CommitmentSigned {
+class COption_MonitorEventZ {
private:
- LDKCommitmentSigned self;
+ LDKCOption_MonitorEventZ self;
public:
- CommitmentSigned(const CommitmentSigned&) = delete;
- CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
- CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
- operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
- ~CommitmentSigned() { CommitmentSigned_free(self); }
- CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
- LDKCommitmentSigned* operator &() { return &self; }
- LDKCommitmentSigned* operator ->() { return &self; }
- const LDKCommitmentSigned* operator &() const { return &self; }
- const LDKCommitmentSigned* operator ->() const { return &self; }
+ COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
+ COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
+ COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
+ operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
+ ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
+ COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
+ LDKCOption_MonitorEventZ* operator &() { return &self; }
+ LDKCOption_MonitorEventZ* operator ->() { return &self; }
+ const LDKCOption_MonitorEventZ* operator &() const { return &self; }
+ const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
};
-class RevokeAndACK {
+class COption_TypeZ {
private:
- LDKRevokeAndACK self;
+ LDKCOption_TypeZ self;
public:
- RevokeAndACK(const RevokeAndACK&) = delete;
- RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
- RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
- operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
- ~RevokeAndACK() { RevokeAndACK_free(self); }
- RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
- LDKRevokeAndACK* operator &() { return &self; }
- LDKRevokeAndACK* operator ->() { return &self; }
- const LDKRevokeAndACK* operator &() const { return &self; }
- const LDKRevokeAndACK* operator ->() const { return &self; }
+ COption_TypeZ(const COption_TypeZ&) = delete;
+ COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
+ COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
+ operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
+ ~COption_TypeZ() { COption_TypeZ_free(self); }
+ COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
+ LDKCOption_TypeZ* operator &() { return &self; }
+ LDKCOption_TypeZ* operator ->() { return &self; }
+ const LDKCOption_TypeZ* operator &() const { return &self; }
+ const LDKCOption_TypeZ* operator ->() const { return &self; }
+};
+class CResult_COption_TypeZDecodeErrorZ {
+private:
+ LDKCResult_COption_TypeZDecodeErrorZ self;
+public:
+ CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
+ CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
+ CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
+ operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
+ ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
+ CResult_COption_TypeZDecodeErrorZ& operator=(CResult_COption_TypeZDecodeErrorZ&& o) { CResult_COption_TypeZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
};
-class UpdateFee {
-private:
- LDKUpdateFee self;
-public:
- UpdateFee(const UpdateFee&) = delete;
- UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
- UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
- operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
- ~UpdateFee() { UpdateFee_free(self); }
- UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
- LDKUpdateFee* operator &() { return &self; }
- LDKUpdateFee* operator ->() { return &self; }
- const LDKUpdateFee* operator &() const { return &self; }
- const LDKUpdateFee* operator ->() const { return &self; }
+class CResult_OfferDecodeErrorZ {
+private:
+ LDKCResult_OfferDecodeErrorZ self;
+public:
+ CResult_OfferDecodeErrorZ(const CResult_OfferDecodeErrorZ&) = delete;
+ CResult_OfferDecodeErrorZ(CResult_OfferDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferDecodeErrorZ)); }
+ CResult_OfferDecodeErrorZ(LDKCResult_OfferDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferDecodeErrorZ)); }
+ operator LDKCResult_OfferDecodeErrorZ() && { LDKCResult_OfferDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferDecodeErrorZ)); return res; }
+ ~CResult_OfferDecodeErrorZ() { CResult_OfferDecodeErrorZ_free(self); }
+ CResult_OfferDecodeErrorZ& operator=(CResult_OfferDecodeErrorZ&& o) { CResult_OfferDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferDecodeErrorZ)); return *this; }
+ LDKCResult_OfferDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OfferDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OfferDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OfferDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_PathFailureZDecodeErrorZ {
+private:
+ LDKCResult_COption_PathFailureZDecodeErrorZ self;
+public:
+ CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
+ CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
+ CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
+ operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
+ ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
+ CResult_COption_PathFailureZDecodeErrorZ& operator=(CResult_COption_PathFailureZDecodeErrorZ&& o) { CResult_COption_PathFailureZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_Bolt11InvoiceSignOrCreationErrorZ {
+private:
+ LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
+public:
+ CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
+ CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
+ CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
+ operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
+ ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
+ CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
+ LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+};
+class CResult_BlindedMessagePathNoneZ {
+private:
+ LDKCResult_BlindedMessagePathNoneZ self;
+public:
+ CResult_BlindedMessagePathNoneZ(const CResult_BlindedMessagePathNoneZ&) = delete;
+ CResult_BlindedMessagePathNoneZ(CResult_BlindedMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedMessagePathNoneZ)); }
+ CResult_BlindedMessagePathNoneZ(LDKCResult_BlindedMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedMessagePathNoneZ)); }
+ operator LDKCResult_BlindedMessagePathNoneZ() && { LDKCResult_BlindedMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedMessagePathNoneZ)); return res; }
+ ~CResult_BlindedMessagePathNoneZ() { CResult_BlindedMessagePathNoneZ_free(self); }
+ CResult_BlindedMessagePathNoneZ& operator=(CResult_BlindedMessagePathNoneZ&& o) { CResult_BlindedMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedMessagePathNoneZ)); return *this; }
+ LDKCResult_BlindedMessagePathNoneZ* operator &() { return &self; }
+ LDKCResult_BlindedMessagePathNoneZ* operator ->() { return &self; }
+ const LDKCResult_BlindedMessagePathNoneZ* operator &() const { return &self; }
+ const LDKCResult_BlindedMessagePathNoneZ* operator ->() const { return &self; }
};
-class DataLossProtect {
+class CResult_UpdateFailHTLCDecodeErrorZ {
private:
- LDKDataLossProtect self;
+ LDKCResult_UpdateFailHTLCDecodeErrorZ self;
public:
- DataLossProtect(const DataLossProtect&) = delete;
- DataLossProtect(DataLossProtect&& o) : self(o.self) { memset(&o, 0, sizeof(DataLossProtect)); }
- DataLossProtect(LDKDataLossProtect&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDataLossProtect)); }
- operator LDKDataLossProtect() && { LDKDataLossProtect res = self; memset(&self, 0, sizeof(LDKDataLossProtect)); return res; }
- ~DataLossProtect() { DataLossProtect_free(self); }
- DataLossProtect& operator=(DataLossProtect&& o) { DataLossProtect_free(self); self = o.self; memset(&o, 0, sizeof(DataLossProtect)); return *this; }
- LDKDataLossProtect* operator &() { return &self; }
- LDKDataLossProtect* operator ->() { return &self; }
- const LDKDataLossProtect* operator &() const { return &self; }
- const LDKDataLossProtect* operator ->() const { return &self; }
+ CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
+ CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
+ CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
+ operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
+ ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
+ CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
};
-class ChannelReestablish {
+class CResult_BlindedPaymentPathNoneZ {
+private:
+ LDKCResult_BlindedPaymentPathNoneZ self;
+public:
+ CResult_BlindedPaymentPathNoneZ(const CResult_BlindedPaymentPathNoneZ&) = delete;
+ CResult_BlindedPaymentPathNoneZ(CResult_BlindedPaymentPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPaymentPathNoneZ)); }
+ CResult_BlindedPaymentPathNoneZ(LDKCResult_BlindedPaymentPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPaymentPathNoneZ)); }
+ operator LDKCResult_BlindedPaymentPathNoneZ() && { LDKCResult_BlindedPaymentPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPaymentPathNoneZ)); return res; }
+ ~CResult_BlindedPaymentPathNoneZ() { CResult_BlindedPaymentPathNoneZ_free(self); }
+ CResult_BlindedPaymentPathNoneZ& operator=(CResult_BlindedPaymentPathNoneZ&& o) { CResult_BlindedPaymentPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPaymentPathNoneZ)); return *this; }
+ LDKCResult_BlindedPaymentPathNoneZ* operator &() { return &self; }
+ LDKCResult_BlindedPaymentPathNoneZ* operator ->() { return &self; }
+ const LDKCResult_BlindedPaymentPathNoneZ* operator &() const { return &self; }
+ const LDKCResult_BlindedPaymentPathNoneZ* operator ->() const { return &self; }
+};
+class CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ {
+private:
+ LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ self;
+public:
+ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(const CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&) = delete;
+ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); }
+ operator LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ() && { LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return res; }
+ ~CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ() { CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); }
+ CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ& operator=(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ&& o) { CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
+private:
+ LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
+public:
+ CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
+ CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
+ CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
+ operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
+ ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
+ CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return *this; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
+};
+class CResult_SpendableOutputDescriptorDecodeErrorZ {
private:
- LDKChannelReestablish self;
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
public:
- ChannelReestablish(const ChannelReestablish&) = delete;
- ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
- ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
- operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
- ~ChannelReestablish() { ChannelReestablish_free(self); }
- ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
- LDKChannelReestablish* operator &() { return &self; }
- LDKChannelReestablish* operator ->() { return &self; }
- const LDKChannelReestablish* operator &() const { return &self; }
- const LDKChannelReestablish* operator ->() const { return &self; }
+ CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
+ CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
+ CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
+ operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
+ ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
+ CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
};
-class AnnouncementSignatures {
+class CResult_RevokeAndACKDecodeErrorZ {
private:
- LDKAnnouncementSignatures self;
+ LDKCResult_RevokeAndACKDecodeErrorZ self;
public:
- AnnouncementSignatures(const AnnouncementSignatures&) = delete;
- AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
- AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
- operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
- ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
- AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
- LDKAnnouncementSignatures* operator &() { return &self; }
- LDKAnnouncementSignatures* operator ->() { return &self; }
- const LDKAnnouncementSignatures* operator &() const { return &self; }
- const LDKAnnouncementSignatures* operator ->() const { return &self; }
+ CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
+ CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
+ CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
+ operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
+ ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
+ CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
+ LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
};
-class NetAddress {
+class CResult_UnsignedChannelUpdateDecodeErrorZ {
private:
- LDKNetAddress self;
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
public:
- NetAddress(const NetAddress&) = delete;
- NetAddress(NetAddress&& o) : self(o.self) { memset(&o, 0, sizeof(NetAddress)); }
- NetAddress(LDKNetAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetAddress)); }
- operator LDKNetAddress() && { LDKNetAddress res = self; memset(&self, 0, sizeof(LDKNetAddress)); return res; }
- ~NetAddress() { NetAddress_free(self); }
- NetAddress& operator=(NetAddress&& o) { NetAddress_free(self); self = o.self; memset(&o, 0, sizeof(NetAddress)); return *this; }
- LDKNetAddress* operator &() { return &self; }
- LDKNetAddress* operator ->() { return &self; }
- const LDKNetAddress* operator &() const { return &self; }
- const LDKNetAddress* operator ->() const { return &self; }
+ CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
+ CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
+ CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
+ operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
+ ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
+ CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
};
-class UnsignedNodeAnnouncement {
+class CResult_PayeePubKeySecp256k1ErrorZ {
+private:
+ LDKCResult_PayeePubKeySecp256k1ErrorZ self;
+public:
+ CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
+ CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
+ CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
+ operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
+ ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
+ CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
+ LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
+ LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
+ const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
+ const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple__u832u16Z {
+private:
+ LDKC2Tuple__u832u16Z self;
+public:
+ C2Tuple__u832u16Z(const C2Tuple__u832u16Z&) = delete;
+ C2Tuple__u832u16Z(C2Tuple__u832u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u832u16Z)); }
+ C2Tuple__u832u16Z(LDKC2Tuple__u832u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u832u16Z)); }
+ operator LDKC2Tuple__u832u16Z() && { LDKC2Tuple__u832u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u832u16Z)); return res; }
+ ~C2Tuple__u832u16Z() { C2Tuple__u832u16Z_free(self); }
+ C2Tuple__u832u16Z& operator=(C2Tuple__u832u16Z&& o) { C2Tuple__u832u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u832u16Z)); return *this; }
+ LDKC2Tuple__u832u16Z* operator &() { return &self; }
+ LDKC2Tuple__u832u16Z* operator ->() { return &self; }
+ const LDKC2Tuple__u832u16Z* operator &() const { return &self; }
+ const LDKC2Tuple__u832u16Z* operator ->() const { return &self; }
+};
+class CResult_BlindedMessagePathDecodeErrorZ {
+private:
+ LDKCResult_BlindedMessagePathDecodeErrorZ self;
+public:
+ CResult_BlindedMessagePathDecodeErrorZ(const CResult_BlindedMessagePathDecodeErrorZ&) = delete;
+ CResult_BlindedMessagePathDecodeErrorZ(CResult_BlindedMessagePathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedMessagePathDecodeErrorZ)); }
+ CResult_BlindedMessagePathDecodeErrorZ(LDKCResult_BlindedMessagePathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedMessagePathDecodeErrorZ)); }
+ operator LDKCResult_BlindedMessagePathDecodeErrorZ() && { LDKCResult_BlindedMessagePathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedMessagePathDecodeErrorZ)); return res; }
+ ~CResult_BlindedMessagePathDecodeErrorZ() { CResult_BlindedMessagePathDecodeErrorZ_free(self); }
+ CResult_BlindedMessagePathDecodeErrorZ& operator=(CResult_BlindedMessagePathDecodeErrorZ&& o) { CResult_BlindedMessagePathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedMessagePathDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedMessagePathDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedMessagePathDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedMessagePathDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedMessagePathDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_BlindedMessagePathZNoneZ {
+private:
+ LDKCResult_CVec_BlindedMessagePathZNoneZ self;
+public:
+ CResult_CVec_BlindedMessagePathZNoneZ(const CResult_CVec_BlindedMessagePathZNoneZ&) = delete;
+ CResult_CVec_BlindedMessagePathZNoneZ(CResult_CVec_BlindedMessagePathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedMessagePathZNoneZ)); }
+ CResult_CVec_BlindedMessagePathZNoneZ(LDKCResult_CVec_BlindedMessagePathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedMessagePathZNoneZ)); }
+ operator LDKCResult_CVec_BlindedMessagePathZNoneZ() && { LDKCResult_CVec_BlindedMessagePathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedMessagePathZNoneZ)); return res; }
+ ~CResult_CVec_BlindedMessagePathZNoneZ() { CResult_CVec_BlindedMessagePathZNoneZ_free(self); }
+ CResult_CVec_BlindedMessagePathZNoneZ& operator=(CResult_CVec_BlindedMessagePathZNoneZ&& o) { CResult_CVec_BlindedMessagePathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedMessagePathZNoneZ)); return *this; }
+ LDKCResult_CVec_BlindedMessagePathZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_BlindedMessagePathZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_BlindedMessagePathZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_BlindedMessagePathZNoneZ* operator ->() const { return &self; }
+};
+class COption_BigEndianScalarZ {
+private:
+ LDKCOption_BigEndianScalarZ self;
+public:
+ COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
+ COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
+ COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
+ operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
+ ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
+ COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
+ LDKCOption_BigEndianScalarZ* operator &() { return &self; }
+ LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
+ const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
+ const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
+};
+class CVec_ChannelIdZ {
+private:
+ LDKCVec_ChannelIdZ self;
+public:
+ CVec_ChannelIdZ(const CVec_ChannelIdZ&) = delete;
+ CVec_ChannelIdZ(CVec_ChannelIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelIdZ)); }
+ CVec_ChannelIdZ(LDKCVec_ChannelIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelIdZ)); }
+ operator LDKCVec_ChannelIdZ() && { LDKCVec_ChannelIdZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelIdZ)); return res; }
+ ~CVec_ChannelIdZ() { CVec_ChannelIdZ_free(self); }
+ CVec_ChannelIdZ& operator=(CVec_ChannelIdZ&& o) { CVec_ChannelIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelIdZ)); return *this; }
+ LDKCVec_ChannelIdZ* operator &() { return &self; }
+ LDKCVec_ChannelIdZ* operator ->() { return &self; }
+ const LDKCVec_ChannelIdZ* operator &() const { return &self; }
+ const LDKCVec_ChannelIdZ* operator ->() const { return &self; }
+};
+class CResult_PublicKeySecp256k1ErrorZ {
+private:
+ LDKCResult_PublicKeySecp256k1ErrorZ self;
+public:
+ CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
+ CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
+ CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
+ operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
+ ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
+ CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
+ LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
+ LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
+ const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
+ const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_OnionMessageContentsMessageSendInstructionsZ {
+private:
+ LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ self;
+public:
+ C2Tuple_OnionMessageContentsMessageSendInstructionsZ(const C2Tuple_OnionMessageContentsMessageSendInstructionsZ&) = delete;
+ C2Tuple_OnionMessageContentsMessageSendInstructionsZ(C2Tuple_OnionMessageContentsMessageSendInstructionsZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsMessageSendInstructionsZ)); }
+ C2Tuple_OnionMessageContentsMessageSendInstructionsZ(LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ)); }
+ operator LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ() && { LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ)); return res; }
+ ~C2Tuple_OnionMessageContentsMessageSendInstructionsZ() { C2Tuple_OnionMessageContentsMessageSendInstructionsZ_free(self); }
+ C2Tuple_OnionMessageContentsMessageSendInstructionsZ& operator=(C2Tuple_OnionMessageContentsMessageSendInstructionsZ&& o) { C2Tuple_OnionMessageContentsMessageSendInstructionsZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OnionMessageContentsMessageSendInstructionsZ)); return *this; }
+ LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator &() { return &self; }
+ LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator ->() { return &self; }
+ const LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator &() const { return &self; }
+ const LDKC2Tuple_OnionMessageContentsMessageSendInstructionsZ* operator ->() const { return &self; }
+};
+class CVec_BlindedHopZ {
+private:
+ LDKCVec_BlindedHopZ self;
+public:
+ CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
+ CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
+ CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
+ operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
+ ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
+ CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
+ LDKCVec_BlindedHopZ* operator &() { return &self; }
+ LDKCVec_BlindedHopZ* operator ->() { return &self; }
+ const LDKCVec_BlindedHopZ* operator &() const { return &self; }
+ const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
+};
+class CResult_ReleaseHeldHtlcDecodeErrorZ {
+private:
+ LDKCResult_ReleaseHeldHtlcDecodeErrorZ self;
+public:
+ CResult_ReleaseHeldHtlcDecodeErrorZ(const CResult_ReleaseHeldHtlcDecodeErrorZ&) = delete;
+ CResult_ReleaseHeldHtlcDecodeErrorZ(CResult_ReleaseHeldHtlcDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReleaseHeldHtlcDecodeErrorZ)); }
+ CResult_ReleaseHeldHtlcDecodeErrorZ(LDKCResult_ReleaseHeldHtlcDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReleaseHeldHtlcDecodeErrorZ)); }
+ operator LDKCResult_ReleaseHeldHtlcDecodeErrorZ() && { LDKCResult_ReleaseHeldHtlcDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReleaseHeldHtlcDecodeErrorZ)); return res; }
+ ~CResult_ReleaseHeldHtlcDecodeErrorZ() { CResult_ReleaseHeldHtlcDecodeErrorZ_free(self); }
+ CResult_ReleaseHeldHtlcDecodeErrorZ& operator=(CResult_ReleaseHeldHtlcDecodeErrorZ&& o) { CResult_ReleaseHeldHtlcDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReleaseHeldHtlcDecodeErrorZ)); return *this; }
+ LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ReleaseHeldHtlcDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_ECDSASignatureZNoneZ {
+private:
+ LDKCResult_CVec_ECDSASignatureZNoneZ self;
+public:
+ CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
+ CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
+ CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
+ operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
+ ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
+ CResult_CVec_ECDSASignatureZNoneZ& operator=(CResult_CVec_ECDSASignatureZNoneZ&& o) { CResult_CVec_ECDSASignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); return *this; }
+ LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
+};
+class CResult_COption_ClosureReasonZDecodeErrorZ {
private:
- LDKUnsignedNodeAnnouncement self;
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
public:
- UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
- UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
- UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
- operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
- ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
- UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
- LDKUnsignedNodeAnnouncement* operator &() { return &self; }
- LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
- const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
- const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
+ CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
+ CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
+ CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
+ operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
+ ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
+ CResult_COption_ClosureReasonZDecodeErrorZ& operator=(CResult_COption_ClosureReasonZDecodeErrorZ&& o) { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
};
-class NodeAnnouncement {
+class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
private:
- LDKNodeAnnouncement self;
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
public:
- NodeAnnouncement(const NodeAnnouncement&) = delete;
- NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
- NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
- operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
- ~NodeAnnouncement() { NodeAnnouncement_free(self); }
- NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
- LDKNodeAnnouncement* operator &() { return &self; }
- LDKNodeAnnouncement* operator ->() { return &self; }
- const LDKNodeAnnouncement* operator &() const { return &self; }
- const LDKNodeAnnouncement* operator ->() const { return &self; }
+ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
+ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
+ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
+ operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
+ ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
+ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
+ LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
+ const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
+ const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
};
-class UnsignedChannelAnnouncement {
+class CResult_NonceDecodeErrorZ {
private:
- LDKUnsignedChannelAnnouncement self;
+ LDKCResult_NonceDecodeErrorZ self;
public:
- UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
- UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
- UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
- operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
- ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
- UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
- LDKUnsignedChannelAnnouncement* operator &() { return &self; }
- LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
- const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
- const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
+ CResult_NonceDecodeErrorZ(const CResult_NonceDecodeErrorZ&) = delete;
+ CResult_NonceDecodeErrorZ(CResult_NonceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonceDecodeErrorZ)); }
+ CResult_NonceDecodeErrorZ(LDKCResult_NonceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonceDecodeErrorZ)); }
+ operator LDKCResult_NonceDecodeErrorZ() && { LDKCResult_NonceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonceDecodeErrorZ)); return res; }
+ ~CResult_NonceDecodeErrorZ() { CResult_NonceDecodeErrorZ_free(self); }
+ CResult_NonceDecodeErrorZ& operator=(CResult_NonceDecodeErrorZ&& o) { CResult_NonceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonceDecodeErrorZ)); return *this; }
+ LDKCResult_NonceDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NonceDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NonceDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NonceDecodeErrorZ* operator ->() const { return &self; }
};
-class ChannelAnnouncement {
+class CResult_RouteParametersDecodeErrorZ {
private:
- LDKChannelAnnouncement self;
+ LDKCResult_RouteParametersDecodeErrorZ self;
public:
- ChannelAnnouncement(const ChannelAnnouncement&) = delete;
- ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
- ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
- operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
- ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
- ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
- LDKChannelAnnouncement* operator &() { return &self; }
- LDKChannelAnnouncement* operator ->() { return &self; }
- const LDKChannelAnnouncement* operator &() const { return &self; }
- const LDKChannelAnnouncement* operator ->() const { return &self; }
+ CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
+ CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
+ CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
+ operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
+ ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
+ CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
+ LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
};
-class UnsignedChannelUpdate {
+class CResult_PrivateRouteCreationErrorZ {
private:
- LDKUnsignedChannelUpdate self;
+ LDKCResult_PrivateRouteCreationErrorZ self;
public:
- UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
- UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
- UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
- operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
- ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
- UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
- LDKUnsignedChannelUpdate* operator &() { return &self; }
- LDKUnsignedChannelUpdate* operator ->() { return &self; }
- const LDKUnsignedChannelUpdate* operator &() const { return &self; }
- const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
+ CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
+ CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
+ CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
+ operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
+ ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
+ CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
+ LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
+ LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
+ const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
+ const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
};
-class ChannelUpdate {
+class CResult_InvoiceErrorDecodeErrorZ {
private:
- LDKChannelUpdate self;
+ LDKCResult_InvoiceErrorDecodeErrorZ self;
public:
- ChannelUpdate(const ChannelUpdate&) = delete;
- ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
- ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
- operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
- ~ChannelUpdate() { ChannelUpdate_free(self); }
- ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
- LDKChannelUpdate* operator &() { return &self; }
- LDKChannelUpdate* operator ->() { return &self; }
- const LDKChannelUpdate* operator &() const { return &self; }
- const LDKChannelUpdate* operator ->() const { return &self; }
+ CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
+ CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
+ CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
+ operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
+ ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
+ CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
+ LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
};
-class QueryChannelRange {
+class CResult_NodeAliasDecodeErrorZ {
private:
- LDKQueryChannelRange self;
+ LDKCResult_NodeAliasDecodeErrorZ self;
public:
- QueryChannelRange(const QueryChannelRange&) = delete;
- QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
- QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
- operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
- ~QueryChannelRange() { QueryChannelRange_free(self); }
- QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
- LDKQueryChannelRange* operator &() { return &self; }
- LDKQueryChannelRange* operator ->() { return &self; }
- const LDKQueryChannelRange* operator &() const { return &self; }
- const LDKQueryChannelRange* operator ->() const { return &self; }
+ CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
+ CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
+ CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
+ operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
+ ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
+ CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
+ LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
};
-class ReplyChannelRange {
+class C2Tuple_BestBlockOutputSweeperZ {
private:
- LDKReplyChannelRange self;
+ LDKC2Tuple_BestBlockOutputSweeperZ self;
public:
- ReplyChannelRange(const ReplyChannelRange&) = delete;
- ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
- ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
- operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
- ~ReplyChannelRange() { ReplyChannelRange_free(self); }
- ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
- LDKReplyChannelRange* operator &() { return &self; }
- LDKReplyChannelRange* operator ->() { return &self; }
- const LDKReplyChannelRange* operator &() const { return &self; }
- const LDKReplyChannelRange* operator ->() const { return &self; }
+ C2Tuple_BestBlockOutputSweeperZ(const C2Tuple_BestBlockOutputSweeperZ&) = delete;
+ C2Tuple_BestBlockOutputSweeperZ(C2Tuple_BestBlockOutputSweeperZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BestBlockOutputSweeperZ)); }
+ C2Tuple_BestBlockOutputSweeperZ(LDKC2Tuple_BestBlockOutputSweeperZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BestBlockOutputSweeperZ)); }
+ operator LDKC2Tuple_BestBlockOutputSweeperZ() && { LDKC2Tuple_BestBlockOutputSweeperZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BestBlockOutputSweeperZ)); return res; }
+ ~C2Tuple_BestBlockOutputSweeperZ() { C2Tuple_BestBlockOutputSweeperZ_free(self); }
+ C2Tuple_BestBlockOutputSweeperZ& operator=(C2Tuple_BestBlockOutputSweeperZ&& o) { C2Tuple_BestBlockOutputSweeperZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BestBlockOutputSweeperZ)); return *this; }
+ LDKC2Tuple_BestBlockOutputSweeperZ* operator &() { return &self; }
+ LDKC2Tuple_BestBlockOutputSweeperZ* operator ->() { return &self; }
+ const LDKC2Tuple_BestBlockOutputSweeperZ* operator &() const { return &self; }
+ const LDKC2Tuple_BestBlockOutputSweeperZ* operator ->() const { return &self; }
};
-class QueryShortChannelIds {
+class C2Tuple_OutPointCVec_u64ZZ {
private:
- LDKQueryShortChannelIds self;
+ LDKC2Tuple_OutPointCVec_u64ZZ self;
public:
- QueryShortChannelIds(const QueryShortChannelIds&) = delete;
- QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
- QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
- operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
- ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
- QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
- LDKQueryShortChannelIds* operator &() { return &self; }
- LDKQueryShortChannelIds* operator ->() { return &self; }
- const LDKQueryShortChannelIds* operator &() const { return &self; }
- const LDKQueryShortChannelIds* operator ->() const { return &self; }
+ C2Tuple_OutPointCVec_u64ZZ(const C2Tuple_OutPointCVec_u64ZZ&) = delete;
+ C2Tuple_OutPointCVec_u64ZZ(C2Tuple_OutPointCVec_u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u64ZZ)); }
+ C2Tuple_OutPointCVec_u64ZZ(LDKC2Tuple_OutPointCVec_u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u64ZZ)); }
+ operator LDKC2Tuple_OutPointCVec_u64ZZ() && { LDKC2Tuple_OutPointCVec_u64ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u64ZZ)); return res; }
+ ~C2Tuple_OutPointCVec_u64ZZ() { C2Tuple_OutPointCVec_u64ZZ_free(self); }
+ C2Tuple_OutPointCVec_u64ZZ& operator=(C2Tuple_OutPointCVec_u64ZZ&& o) { C2Tuple_OutPointCVec_u64ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u64ZZ)); return *this; }
+ LDKC2Tuple_OutPointCVec_u64ZZ* operator &() { return &self; }
+ LDKC2Tuple_OutPointCVec_u64ZZ* operator ->() { return &self; }
+ const LDKC2Tuple_OutPointCVec_u64ZZ* operator &() const { return &self; }
+ const LDKC2Tuple_OutPointCVec_u64ZZ* operator ->() const { return &self; }
};
-class ReplyShortChannelIdsEnd {
+class CVec_UpdateFulfillHTLCZ {
private:
- LDKReplyShortChannelIdsEnd self;
+ LDKCVec_UpdateFulfillHTLCZ self;
public:
- ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
- ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
- ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
- operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
- ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
- ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
- LDKReplyShortChannelIdsEnd* operator &() { return &self; }
- LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
- const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
- const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
+ CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
+ CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
+ CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
+ operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
+ ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
+ CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
+ LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
+ LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
+ const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
+ const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
};
-class GossipTimestampFilter {
+class CVec_C2Tuple_u32CVec_u8ZZZ {
private:
- LDKGossipTimestampFilter self;
+ LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
public:
- GossipTimestampFilter(const GossipTimestampFilter&) = delete;
- GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
- GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
- operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
- ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
- GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
- LDKGossipTimestampFilter* operator &() { return &self; }
- LDKGossipTimestampFilter* operator ->() { return &self; }
- const LDKGossipTimestampFilter* operator &() const { return &self; }
- const LDKGossipTimestampFilter* operator ->() const { return &self; }
+ CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
+ CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
+ CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
+ operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
+ ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
+ CVec_C2Tuple_u32CVec_u8ZZZ& operator=(CVec_C2Tuple_u32CVec_u8ZZZ&& o) { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); return *this; }
+ LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
};
-class ErrorAction {
+class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ {
private:
- LDKErrorAction self;
+ LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ self;
public:
- ErrorAction(const ErrorAction&) = delete;
- ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
- ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
- operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
- ~ErrorAction() { ErrorAction_free(self); }
- ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
- LDKErrorAction* operator &() { return &self; }
- LDKErrorAction* operator ->() { return &self; }
- const LDKErrorAction* operator &() const { return &self; }
- const LDKErrorAction* operator ->() const { return &self; }
+ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(const C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&) = delete;
+ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
+ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
+ operator LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() && { LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return res; }
+ ~C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); }
+ C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ& operator=(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return *this; }
+ LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() { return &self; }
+ LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() { return &self; }
+ const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() const { return &self; }
+ const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
};
-class LightningError {
+class CResult_AnnouncementSignaturesDecodeErrorZ {
private:
- LDKLightningError self;
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ 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; }
+ CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
+ CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
+ CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
+ operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
+ ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
+ CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class CommitmentUpdate {
+class CResult_TxCompleteDecodeErrorZ {
private:
- LDKCommitmentUpdate self;
+ LDKCResult_TxCompleteDecodeErrorZ 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; }
+ CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
+ CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
+ CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
+ operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
+ ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
+ CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
+ LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
};
-class ChannelMessageHandler {
+class CResult_UpdateFulfillHTLCDecodeErrorZ {
private:
- LDKChannelMessageHandler self;
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ 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, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg);
- /**
- * Handle an incoming accept_channel message from the given peer.
- */
- inline void handle_accept_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *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 LDKInitFeatures *NONNULL_PTR their_features, 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 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. If no connection
- * is believed to be possible in the future (eg they're sending us messages we don't
- * understand or indicate they require unknown feature bits), no_connection_possible is set
- * and any outstanding channels should be failed.
- */
- inline void peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible);
- /**
- * Handle a peer reconnecting, possibly generating channel_reestablish message(s).
- */
- inline void peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg);
- /**
- * 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 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);
+ CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
+ CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
+ CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
+ operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
+ ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
+ CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
};
-class RoutingMessageHandler {
+class CResult_NodeFeaturesDecodeErrorZ {
private:
- LDKRoutingMessageHandler self;
+ LDKCResult_NodeFeaturesDecodeErrorZ 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 LDKPublicKey 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.
- */
- inline void peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
- /**
- * 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_ids
- * 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_ids.
- */
- inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds 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);
+ CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
+ CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
+ CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
+ operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
+ ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
+ CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
+ LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class OnionMessageHandler {
+class CResult_InMemorySignerDecodeErrorZ {
private:
- LDKOnionMessageHandler self;
+ LDKCResult_InMemorySignerDecodeErrorZ 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);
- /**
- * Called when a connection is established with a peer. Can be used to track which peers
- * advertise onion message support and are online.
- */
- inline void peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init);
- /**
- * 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, bool no_connection_possible);
- /**
- * 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);
+ CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
+ CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
+ CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
+ operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
+ ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
+ CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
+ LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
};
-class GraphSyncError {
+class CResult_TxSignaturesDecodeErrorZ {
private:
- LDKGraphSyncError self;
+ LDKCResult_TxSignaturesDecodeErrorZ self;
public:
- GraphSyncError(const GraphSyncError&) = delete;
- GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
- GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
- operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
- ~GraphSyncError() { GraphSyncError_free(self); }
- GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
- LDKGraphSyncError* operator &() { return &self; }
- LDKGraphSyncError* operator ->() { return &self; }
- const LDKGraphSyncError* operator &() const { return &self; }
- const LDKGraphSyncError* operator ->() const { return &self; }
+ CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
+ CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
+ CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
+ operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
+ ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
+ CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
+ LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class DefaultRouter {
+class CVec_HTLCDescriptorZ {
private:
- LDKDefaultRouter self;
+ LDKCVec_HTLCDescriptorZ self;
public:
- DefaultRouter(const DefaultRouter&) = delete;
- DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
- DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
- operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
- ~DefaultRouter() { DefaultRouter_free(self); }
- DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
- LDKDefaultRouter* operator &() { return &self; }
- LDKDefaultRouter* operator ->() { return &self; }
- const LDKDefaultRouter* operator &() const { return &self; }
- const LDKDefaultRouter* operator ->() const { return &self; }
+ CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
+ CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
+ CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
+ operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
+ ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
+ CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
+ LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
+ LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
+ const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
+ const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
};
-class Level {
+class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
private:
- LDKLevel self;
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ 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; }
+ CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
+ CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+ CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
+ operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
+ ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
+ CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
};
-class Record {
+class COption_PathFailureZ {
+private:
+ LDKCOption_PathFailureZ self;
+public:
+ COption_PathFailureZ(const COption_PathFailureZ&) = delete;
+ COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
+ COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
+ operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
+ ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
+ COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
+ LDKCOption_PathFailureZ* operator &() { return &self; }
+ LDKCOption_PathFailureZ* operator ->() { return &self; }
+ const LDKCOption_PathFailureZ* operator &() const { return &self; }
+ const LDKCOption_PathFailureZ* operator ->() const { return &self; }
+};
+class COption_MessageContextZ {
+private:
+ LDKCOption_MessageContextZ self;
+public:
+ COption_MessageContextZ(const COption_MessageContextZ&) = delete;
+ COption_MessageContextZ(COption_MessageContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MessageContextZ)); }
+ COption_MessageContextZ(LDKCOption_MessageContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MessageContextZ)); }
+ operator LDKCOption_MessageContextZ() && { LDKCOption_MessageContextZ res = self; memset(&self, 0, sizeof(LDKCOption_MessageContextZ)); return res; }
+ ~COption_MessageContextZ() { COption_MessageContextZ_free(self); }
+ COption_MessageContextZ& operator=(COption_MessageContextZ&& o) { COption_MessageContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MessageContextZ)); return *this; }
+ LDKCOption_MessageContextZ* operator &() { return &self; }
+ LDKCOption_MessageContextZ* operator ->() { return &self; }
+ const LDKCOption_MessageContextZ* operator &() const { return &self; }
+ const LDKCOption_MessageContextZ* operator ->() const { return &self; }
+};
+class CVec_ECDSASignatureZ {
+private:
+ LDKCVec_ECDSASignatureZ self;
+public:
+ CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
+ CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
+ CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
+ operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
+ ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
+ CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
+ LDKCVec_ECDSASignatureZ* operator &() { return &self; }
+ LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
+ const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
+ const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
+};
+class CResult_ChannelUpdateInfoDecodeErrorZ {
private:
- LDKRecord self;
+ LDKCResult_ChannelUpdateInfoDecodeErrorZ 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; }
+ CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
+ CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
+ CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
+ operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
+ ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
+ CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
};
-class Logger {
+class CVec_UpdateFailHTLCZ {
private:
- LDKLogger self;
+ LDKCVec_UpdateFailHTLCZ 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(const struct LDKRecord *NONNULL_PTR record);
+ CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
+ CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
+ CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
+ operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
+ ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
+ CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
+ LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
+ LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
+ const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
+ const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
};
-class FutureCallback {
+class CVec_TxOutZ {
private:
- LDKFutureCallback self;
+ LDKCVec_TxOutZ 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();
+ CVec_TxOutZ(const CVec_TxOutZ&) = delete;
+ CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
+ CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
+ operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
+ ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
+ CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
+ LDKCVec_TxOutZ* operator &() { return &self; }
+ LDKCVec_TxOutZ* operator ->() { return &self; }
+ const LDKCVec_TxOutZ* operator &() const { return &self; }
+ const LDKCVec_TxOutZ* operator ->() const { return &self; }
};
-class Future {
+class CVec_InboundHTLCDetailsZ {
private:
- LDKFuture self;
+ LDKCVec_InboundHTLCDetailsZ 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; }
+ CVec_InboundHTLCDetailsZ(const CVec_InboundHTLCDetailsZ&) = delete;
+ CVec_InboundHTLCDetailsZ(CVec_InboundHTLCDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InboundHTLCDetailsZ)); }
+ CVec_InboundHTLCDetailsZ(LDKCVec_InboundHTLCDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InboundHTLCDetailsZ)); }
+ operator LDKCVec_InboundHTLCDetailsZ() && { LDKCVec_InboundHTLCDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_InboundHTLCDetailsZ)); return res; }
+ ~CVec_InboundHTLCDetailsZ() { CVec_InboundHTLCDetailsZ_free(self); }
+ CVec_InboundHTLCDetailsZ& operator=(CVec_InboundHTLCDetailsZ&& o) { CVec_InboundHTLCDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InboundHTLCDetailsZ)); return *this; }
+ LDKCVec_InboundHTLCDetailsZ* operator &() { return &self; }
+ LDKCVec_InboundHTLCDetailsZ* operator ->() { return &self; }
+ const LDKCVec_InboundHTLCDetailsZ* operator &() const { return &self; }
+ const LDKCVec_InboundHTLCDetailsZ* operator ->() const { return &self; }
};
-class MonitorUpdateId {
+class CVec_OutboundHTLCDetailsZ {
private:
- LDKMonitorUpdateId self;
+ LDKCVec_OutboundHTLCDetailsZ self;
public:
- MonitorUpdateId(const MonitorUpdateId&) = delete;
- MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
- MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
- operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
- ~MonitorUpdateId() { MonitorUpdateId_free(self); }
- MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
- LDKMonitorUpdateId* operator &() { return &self; }
- LDKMonitorUpdateId* operator ->() { return &self; }
- const LDKMonitorUpdateId* operator &() const { return &self; }
- const LDKMonitorUpdateId* operator ->() const { return &self; }
+ CVec_OutboundHTLCDetailsZ(const CVec_OutboundHTLCDetailsZ&) = delete;
+ CVec_OutboundHTLCDetailsZ(CVec_OutboundHTLCDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutboundHTLCDetailsZ)); }
+ CVec_OutboundHTLCDetailsZ(LDKCVec_OutboundHTLCDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutboundHTLCDetailsZ)); }
+ operator LDKCVec_OutboundHTLCDetailsZ() && { LDKCVec_OutboundHTLCDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_OutboundHTLCDetailsZ)); return res; }
+ ~CVec_OutboundHTLCDetailsZ() { CVec_OutboundHTLCDetailsZ_free(self); }
+ CVec_OutboundHTLCDetailsZ& operator=(CVec_OutboundHTLCDetailsZ&& o) { CVec_OutboundHTLCDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutboundHTLCDetailsZ)); return *this; }
+ LDKCVec_OutboundHTLCDetailsZ* operator &() { return &self; }
+ LDKCVec_OutboundHTLCDetailsZ* operator ->() { return &self; }
+ const LDKCVec_OutboundHTLCDetailsZ* operator &() const { return &self; }
+ const LDKCVec_OutboundHTLCDetailsZ* operator ->() const { return &self; }
};
-class Persist {
+class CResult_BuiltCommitmentTransactionDecodeErrorZ {
private:
- LDKPersist self;
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ 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 `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
- * if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
- *
- * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
- * and [`ChannelMonitorUpdateErr`] for requirements when returning errors.
- *
- * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
- * [`Writeable::write`]: crate::util::ser::Writeable::write
- */
- inline LDK::CResult_NoneChannelMonitorUpdateErrZ persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
- /**
- * Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
- * update.
- *
- * Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
- * updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
- * details.
- *
- * During blockchain synchronization operations, 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. 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 `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
- * if you return [`ChannelMonitorUpdateErr::TemporaryFailure`].
- *
- * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
- * [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
- * [`ChannelMonitorUpdateErr`] for requirements when returning errors.
- *
- * [`Writeable::write`]: crate::util::ser::Writeable::write
- *
- * Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
- */
- inline LDK::CResult_NoneChannelMonitorUpdateErrZ update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
+ CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
+ CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
+ CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
+ operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
+ ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
+ CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
};
-class LockedChannelMonitor {
+class CVec_PaymentForwardNodeZ {
private:
- LDKLockedChannelMonitor self;
+ LDKCVec_PaymentForwardNodeZ 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; }
+ CVec_PaymentForwardNodeZ(const CVec_PaymentForwardNodeZ&) = delete;
+ CVec_PaymentForwardNodeZ(CVec_PaymentForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PaymentForwardNodeZ)); }
+ CVec_PaymentForwardNodeZ(LDKCVec_PaymentForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PaymentForwardNodeZ)); }
+ operator LDKCVec_PaymentForwardNodeZ() && { LDKCVec_PaymentForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_PaymentForwardNodeZ)); return res; }
+ ~CVec_PaymentForwardNodeZ() { CVec_PaymentForwardNodeZ_free(self); }
+ CVec_PaymentForwardNodeZ& operator=(CVec_PaymentForwardNodeZ&& o) { CVec_PaymentForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PaymentForwardNodeZ)); return *this; }
+ LDKCVec_PaymentForwardNodeZ* operator &() { return &self; }
+ LDKCVec_PaymentForwardNodeZ* operator ->() { return &self; }
+ const LDKCVec_PaymentForwardNodeZ* operator &() const { return &self; }
+ const LDKCVec_PaymentForwardNodeZ* operator ->() const { return &self; }
};
-class ChainMonitor {
+class CResult_TrackedSpendableOutputDecodeErrorZ {
private:
- LDKChainMonitor self;
+ LDKCResult_TrackedSpendableOutputDecodeErrorZ 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; }
+ CResult_TrackedSpendableOutputDecodeErrorZ(const CResult_TrackedSpendableOutputDecodeErrorZ&) = delete;
+ CResult_TrackedSpendableOutputDecodeErrorZ(CResult_TrackedSpendableOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrackedSpendableOutputDecodeErrorZ)); }
+ CResult_TrackedSpendableOutputDecodeErrorZ(LDKCResult_TrackedSpendableOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrackedSpendableOutputDecodeErrorZ)); }
+ operator LDKCResult_TrackedSpendableOutputDecodeErrorZ() && { LDKCResult_TrackedSpendableOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TrackedSpendableOutputDecodeErrorZ)); return res; }
+ ~CResult_TrackedSpendableOutputDecodeErrorZ() { CResult_TrackedSpendableOutputDecodeErrorZ_free(self); }
+ CResult_TrackedSpendableOutputDecodeErrorZ& operator=(CResult_TrackedSpendableOutputDecodeErrorZ&& o) { CResult_TrackedSpendableOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrackedSpendableOutputDecodeErrorZ)); return *this; }
+ LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TrackedSpendableOutputDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_SpendableOutputDescriptorZ {
private:
const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
};
-class CResult_LockedChannelMonitorNoneZ {
-private:
- LDKCResult_LockedChannelMonitorNoneZ self;
-public:
- CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
- CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
- CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
- operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
- ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
- CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
- LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
- LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
- const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
- const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
-};
-class CResult_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_ResponderDecodeErrorZ {
+private:
+ LDKCResult_ResponderDecodeErrorZ self;
+public:
+ CResult_ResponderDecodeErrorZ(const CResult_ResponderDecodeErrorZ&) = delete;
+ CResult_ResponderDecodeErrorZ(CResult_ResponderDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ResponderDecodeErrorZ)); }
+ CResult_ResponderDecodeErrorZ(LDKCResult_ResponderDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ResponderDecodeErrorZ)); }
+ operator LDKCResult_ResponderDecodeErrorZ() && { LDKCResult_ResponderDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ResponderDecodeErrorZ)); return res; }
+ ~CResult_ResponderDecodeErrorZ() { CResult_ResponderDecodeErrorZ_free(self); }
+ CResult_ResponderDecodeErrorZ& operator=(CResult_ResponderDecodeErrorZ&& o) { CResult_ResponderDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ResponderDecodeErrorZ)); return *this; }
+ LDKCResult_ResponderDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ResponderDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ResponderDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ResponderDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_OutPointCVec_u8ZZ {
+private:
+ LDKC2Tuple_OutPointCVec_u8ZZ self;
+public:
+ C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
+ C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
+ C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
+ operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
+ ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
+ C2Tuple_OutPointCVec_u8ZZ& operator=(C2Tuple_OutPointCVec_u8ZZ&& o) { C2Tuple_OutPointCVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); return *this; }
+ LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
+ LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
+ const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
+ const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
+};
+class CResult_WitnessNoneZ {
+private:
+ LDKCResult_WitnessNoneZ self;
+public:
+ CResult_WitnessNoneZ(const CResult_WitnessNoneZ&) = delete;
+ CResult_WitnessNoneZ(CResult_WitnessNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WitnessNoneZ)); }
+ CResult_WitnessNoneZ(LDKCResult_WitnessNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WitnessNoneZ)); }
+ operator LDKCResult_WitnessNoneZ() && { LDKCResult_WitnessNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_WitnessNoneZ)); return res; }
+ ~CResult_WitnessNoneZ() { CResult_WitnessNoneZ_free(self); }
+ CResult_WitnessNoneZ& operator=(CResult_WitnessNoneZ&& o) { CResult_WitnessNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WitnessNoneZ)); return *this; }
+ LDKCResult_WitnessNoneZ* operator &() { return &self; }
+ LDKCResult_WitnessNoneZ* operator ->() { return &self; }
+ const LDKCResult_WitnessNoneZ* operator &() const { return &self; }
+ const LDKCResult_WitnessNoneZ* operator ->() const { return &self; }
};
class COption_C2Tuple_u64u64ZZ {
private:
const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
};
-class CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ {
-private:
- LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ self;
-public:
- CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(const CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&) = delete;
- CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
- CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); }
- operator LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() && { LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return res; }
- ~CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ() { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); }
- CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ& operator=(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ&& o) { CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ)); return *this; }
- LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() { return &self; }
- LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() { return &self; }
- const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator &() const { return &self; }
- const LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* operator ->() const { return &self; }
-};
-class CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ {
+class CResult_ChannelAnnouncementDecodeErrorZ {
private:
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ self;
+ LDKCResult_ChannelAnnouncementDecodeErrorZ self;
public:
- CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(const CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&) = delete;
- CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
- CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); }
- operator LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() && { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return res; }
- ~CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ() { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); }
- CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ& operator=(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ&& o) { CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ)); return *this; }
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() { return &self; }
- LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() { return &self; }
- const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator &() const { return &self; }
- const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ* operator ->() const { return &self; }
+ CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
+ CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
+ CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
+ operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
+ ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
+ CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_HTLCUpdateDecodeErrorZ {
private:
const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
};
-class C2Tuple_SignatureCVec_SignatureZZ {
-private:
- LDKC2Tuple_SignatureCVec_SignatureZZ self;
-public:
- C2Tuple_SignatureCVec_SignatureZZ(const C2Tuple_SignatureCVec_SignatureZZ&) = delete;
- C2Tuple_SignatureCVec_SignatureZZ(C2Tuple_SignatureCVec_SignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); }
- C2Tuple_SignatureCVec_SignatureZZ(LDKC2Tuple_SignatureCVec_SignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); }
- operator LDKC2Tuple_SignatureCVec_SignatureZZ() && { LDKC2Tuple_SignatureCVec_SignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ)); return res; }
- ~C2Tuple_SignatureCVec_SignatureZZ() { C2Tuple_SignatureCVec_SignatureZZ_free(self); }
- C2Tuple_SignatureCVec_SignatureZZ& operator=(C2Tuple_SignatureCVec_SignatureZZ&& o) { C2Tuple_SignatureCVec_SignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureCVec_SignatureZZ)); return *this; }
- LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() { return &self; }
- LDKC2Tuple_SignatureCVec_SignatureZZ* operator ->() { return &self; }
- const LDKC2Tuple_SignatureCVec_SignatureZZ* operator &() const { return &self; }
- const LDKC2Tuple_SignatureCVec_SignatureZZ* 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_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 CResult_TxAddInputDecodeErrorZ {
+private:
+ LDKCResult_TxAddInputDecodeErrorZ self;
+public:
+ CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
+ CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
+ CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
+ operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
+ ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
+ CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
+ LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_HeldHtlcAvailableDecodeErrorZ {
+private:
+ LDKCResult_HeldHtlcAvailableDecodeErrorZ self;
+public:
+ CResult_HeldHtlcAvailableDecodeErrorZ(const CResult_HeldHtlcAvailableDecodeErrorZ&) = delete;
+ CResult_HeldHtlcAvailableDecodeErrorZ(CResult_HeldHtlcAvailableDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HeldHtlcAvailableDecodeErrorZ)); }
+ CResult_HeldHtlcAvailableDecodeErrorZ(LDKCResult_HeldHtlcAvailableDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HeldHtlcAvailableDecodeErrorZ)); }
+ operator LDKCResult_HeldHtlcAvailableDecodeErrorZ() && { LDKCResult_HeldHtlcAvailableDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HeldHtlcAvailableDecodeErrorZ)); return res; }
+ ~CResult_HeldHtlcAvailableDecodeErrorZ() { CResult_HeldHtlcAvailableDecodeErrorZ_free(self); }
+ CResult_HeldHtlcAvailableDecodeErrorZ& operator=(CResult_HeldHtlcAvailableDecodeErrorZ&& o) { CResult_HeldHtlcAvailableDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HeldHtlcAvailableDecodeErrorZ)); return *this; }
+ LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HeldHtlcAvailableDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_TxInitRbfDecodeErrorZ {
+private:
+ LDKCResult_TxInitRbfDecodeErrorZ self;
+public:
+ CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
+ CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
+ CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
+ operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
+ ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
+ CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
+ LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
};
class COption_WriteableScoreZ {
private:
const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
const LDKCOption_WriteableScoreZ* 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_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 CResult_ChannelAnnouncementDecodeErrorZ {
-private:
- LDKCResult_ChannelAnnouncementDecodeErrorZ self;
-public:
- CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
- CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
- CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
- operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
- ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
- CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
- LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+class CVec_StrZ {
+private:
+ LDKCVec_StrZ self;
+public:
+ CVec_StrZ(const CVec_StrZ&) = delete;
+ CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
+ CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
+ operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
+ ~CVec_StrZ() { CVec_StrZ_free(self); }
+ CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
+ LDKCVec_StrZ* operator &() { return &self; }
+ LDKCVec_StrZ* operator ->() { return &self; }
+ const LDKCVec_StrZ* operator &() const { return &self; }
+ const LDKCVec_StrZ* operator ->() const { return &self; }
+};
+class CResult_AsyncPaymentsMessageDecodeErrorZ {
+private:
+ LDKCResult_AsyncPaymentsMessageDecodeErrorZ self;
+public:
+ CResult_AsyncPaymentsMessageDecodeErrorZ(const CResult_AsyncPaymentsMessageDecodeErrorZ&) = delete;
+ CResult_AsyncPaymentsMessageDecodeErrorZ(CResult_AsyncPaymentsMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AsyncPaymentsMessageDecodeErrorZ)); }
+ CResult_AsyncPaymentsMessageDecodeErrorZ(LDKCResult_AsyncPaymentsMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AsyncPaymentsMessageDecodeErrorZ)); }
+ operator LDKCResult_AsyncPaymentsMessageDecodeErrorZ() && { LDKCResult_AsyncPaymentsMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AsyncPaymentsMessageDecodeErrorZ)); return res; }
+ ~CResult_AsyncPaymentsMessageDecodeErrorZ() { CResult_AsyncPaymentsMessageDecodeErrorZ_free(self); }
+ CResult_AsyncPaymentsMessageDecodeErrorZ& operator=(CResult_AsyncPaymentsMessageDecodeErrorZ&& o) { CResult_AsyncPaymentsMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AsyncPaymentsMessageDecodeErrorZ)); return *this; }
+ LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_AsyncPaymentsMessageDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SpliceAckDecodeErrorZ {
+private:
+ LDKCResult_SpliceAckDecodeErrorZ self;
+public:
+ CResult_SpliceAckDecodeErrorZ(const CResult_SpliceAckDecodeErrorZ&) = delete;
+ CResult_SpliceAckDecodeErrorZ(CResult_SpliceAckDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); }
+ CResult_SpliceAckDecodeErrorZ(LDKCResult_SpliceAckDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); }
+ operator LDKCResult_SpliceAckDecodeErrorZ() && { LDKCResult_SpliceAckDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); return res; }
+ ~CResult_SpliceAckDecodeErrorZ() { CResult_SpliceAckDecodeErrorZ_free(self); }
+ CResult_SpliceAckDecodeErrorZ& operator=(CResult_SpliceAckDecodeErrorZ&& o) { CResult_SpliceAckDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); return *this; }
+ LDKCResult_SpliceAckDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_SpliceAckDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_SpliceAckDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_SpliceAckDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_PositiveTimestampCreationErrorZ {
private:
const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
};
-class CVec_OutPointZ {
-private:
- LDKCVec_OutPointZ self;
-public:
- CVec_OutPointZ(const CVec_OutPointZ&) = delete;
- CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
- CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
- operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
- ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
- CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
- LDKCVec_OutPointZ* operator &() { return &self; }
- LDKCVec_OutPointZ* operator ->() { return &self; }
- const LDKCVec_OutPointZ* operator &() const { return &self; }
- const LDKCVec_OutPointZ* operator ->() const { return &self; }
-};
-class CResult_CVec_u8ZPeerHandleErrorZ {
+class CResult_PeeledOnionNoneZ {
private:
- LDKCResult_CVec_u8ZPeerHandleErrorZ self;
+ LDKCResult_PeeledOnionNoneZ 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; }
+ CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
+ CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
+ CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
+ operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
+ ~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
+ CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
+ LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
+ LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
+ const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
+ const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
};
-class CResult_InvoiceFeaturesDecodeErrorZ {
+class CVec_C2Tuple_OutPointChannelIdZZ {
private:
- LDKCResult_InvoiceFeaturesDecodeErrorZ self;
+ LDKCVec_C2Tuple_OutPointChannelIdZZ self;
public:
- CResult_InvoiceFeaturesDecodeErrorZ(const CResult_InvoiceFeaturesDecodeErrorZ&) = delete;
- CResult_InvoiceFeaturesDecodeErrorZ(CResult_InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); }
- CResult_InvoiceFeaturesDecodeErrorZ(LDKCResult_InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); }
- operator LDKCResult_InvoiceFeaturesDecodeErrorZ() && { LDKCResult_InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ)); return res; }
- ~CResult_InvoiceFeaturesDecodeErrorZ() { CResult_InvoiceFeaturesDecodeErrorZ_free(self); }
- CResult_InvoiceFeaturesDecodeErrorZ& operator=(CResult_InvoiceFeaturesDecodeErrorZ&& o) { CResult_InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceFeaturesDecodeErrorZ)); return *this; }
- LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
- LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
+ CVec_C2Tuple_OutPointChannelIdZZ(const CVec_C2Tuple_OutPointChannelIdZZ&) = delete;
+ CVec_C2Tuple_OutPointChannelIdZZ(CVec_C2Tuple_OutPointChannelIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointChannelIdZZ)); }
+ CVec_C2Tuple_OutPointChannelIdZZ(LDKCVec_C2Tuple_OutPointChannelIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointChannelIdZZ)); }
+ operator LDKCVec_C2Tuple_OutPointChannelIdZZ() && { LDKCVec_C2Tuple_OutPointChannelIdZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointChannelIdZZ)); return res; }
+ ~CVec_C2Tuple_OutPointChannelIdZZ() { CVec_C2Tuple_OutPointChannelIdZZ_free(self); }
+ CVec_C2Tuple_OutPointChannelIdZZ& operator=(CVec_C2Tuple_OutPointChannelIdZZ&& o) { CVec_C2Tuple_OutPointChannelIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointChannelIdZZ)); return *this; }
+ LDKCVec_C2Tuple_OutPointChannelIdZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_OutPointChannelIdZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_OutPointChannelIdZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_OutPointChannelIdZZ* operator ->() const { return &self; }
};
-class COption_NetworkUpdateZ {
+class CResult_ChannelMonitorUpdateDecodeErrorZ {
private:
- LDKCOption_NetworkUpdateZ self;
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ 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; }
+ CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
+ CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
+ CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
+ operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
+ ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
+ CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
};
-class COption_u64Z {
+class CResult_ReplyChannelRangeDecodeErrorZ {
private:
- LDKCOption_u64Z self;
+ LDKCResult_ReplyChannelRangeDecodeErrorZ 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; }
+ CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
+ CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
+ CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
+ operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
+ ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
+ CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_TxOutAccessErrorZ {
+class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
private:
- LDKCResult_TxOutAccessErrorZ self;
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
public:
- CResult_TxOutAccessErrorZ(const CResult_TxOutAccessErrorZ&) = delete;
- CResult_TxOutAccessErrorZ(CResult_TxOutAccessErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); }
- CResult_TxOutAccessErrorZ(LDKCResult_TxOutAccessErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); }
- operator LDKCResult_TxOutAccessErrorZ() && { LDKCResult_TxOutAccessErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutAccessErrorZ)); return res; }
- ~CResult_TxOutAccessErrorZ() { CResult_TxOutAccessErrorZ_free(self); }
- CResult_TxOutAccessErrorZ& operator=(CResult_TxOutAccessErrorZ&& o) { CResult_TxOutAccessErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutAccessErrorZ)); return *this; }
- LDKCResult_TxOutAccessErrorZ* operator &() { return &self; }
- LDKCResult_TxOutAccessErrorZ* operator ->() { return &self; }
- const LDKCResult_TxOutAccessErrorZ* operator &() const { return &self; }
- const LDKCResult_TxOutAccessErrorZ* operator ->() const { return &self; }
+ CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
+ CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
+ CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
+ operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
+ ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
+ CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_TrustedClosingTransactionNoneZ {
private:
const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
};
-class CResult_PaymentPreimageAPIErrorZ {
-private:
- LDKCResult_PaymentPreimageAPIErrorZ self;
-public:
- CResult_PaymentPreimageAPIErrorZ(const CResult_PaymentPreimageAPIErrorZ&) = delete;
- CResult_PaymentPreimageAPIErrorZ(CResult_PaymentPreimageAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); }
- CResult_PaymentPreimageAPIErrorZ(LDKCResult_PaymentPreimageAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); }
- operator LDKCResult_PaymentPreimageAPIErrorZ() && { LDKCResult_PaymentPreimageAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPreimageAPIErrorZ)); return res; }
- ~CResult_PaymentPreimageAPIErrorZ() { CResult_PaymentPreimageAPIErrorZ_free(self); }
- CResult_PaymentPreimageAPIErrorZ& operator=(CResult_PaymentPreimageAPIErrorZ&& o) { CResult_PaymentPreimageAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPreimageAPIErrorZ)); return *this; }
- LDKCResult_PaymentPreimageAPIErrorZ* operator &() { return &self; }
- LDKCResult_PaymentPreimageAPIErrorZ* operator ->() { return &self; }
- const LDKCResult_PaymentPreimageAPIErrorZ* operator &() const { return &self; }
- const LDKCResult_PaymentPreimageAPIErrorZ* operator ->() const { return &self; }
-};
-class CResult_ChannelMonitorUpdateDecodeErrorZ {
-private:
- LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
-public:
- CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
- CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
- CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
- operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
- ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
- CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
- LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
-};
-class 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 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
+private:
+ LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
+public:
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
+ operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
+ ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ& operator=(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return *this; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
};
class C2Tuple_PublicKeyTypeZ {
private:
const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
};
-class CResult_NetAddressDecodeErrorZ {
-private:
- LDKCResult_NetAddressDecodeErrorZ self;
-public:
- CResult_NetAddressDecodeErrorZ(const CResult_NetAddressDecodeErrorZ&) = delete;
- CResult_NetAddressDecodeErrorZ(CResult_NetAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetAddressDecodeErrorZ)); }
- CResult_NetAddressDecodeErrorZ(LDKCResult_NetAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetAddressDecodeErrorZ)); }
- operator LDKCResult_NetAddressDecodeErrorZ() && { LDKCResult_NetAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetAddressDecodeErrorZ)); return res; }
- ~CResult_NetAddressDecodeErrorZ() { CResult_NetAddressDecodeErrorZ_free(self); }
- CResult_NetAddressDecodeErrorZ& operator=(CResult_NetAddressDecodeErrorZ&& o) { CResult_NetAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetAddressDecodeErrorZ)); return *this; }
- LDKCResult_NetAddressDecodeErrorZ* operator &() { return &self; }
- LDKCResult_NetAddressDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_NetAddressDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_NetAddressDecodeErrorZ* operator ->() const { return &self; }
-};
-class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
+class CResult_TxRemoveOutputDecodeErrorZ {
private:
- LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
+ LDKCResult_TxRemoveOutputDecodeErrorZ 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; }
+ CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
+ CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
+ CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
+ operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
+ ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
+ CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
+ LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_ChannelReestablishDecodeErrorZ {
private:
const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_UpdateAddHTLCZ {
+class CResult_OnionMessageDecodeErrorZ {
private:
- LDKCVec_UpdateAddHTLCZ self;
+ LDKCResult_OnionMessageDecodeErrorZ 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; }
+ CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
+ CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
+ CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
+ operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
+ ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
+ CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
+ LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_CommitmentSignedDecodeErrorZ {
+class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
private:
- LDKCResult_CommitmentSignedDecodeErrorZ self;
+ LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
public:
- CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
- CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
- CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
- operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
- ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
- CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
- LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
- LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
+ CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
+ CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
+ CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
+ operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
+ ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
+ CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
+ LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
};
-class COption_u32Z {
+class CResult_MessageContextDecodeErrorZ {
private:
- LDKCOption_u32Z self;
+ LDKCResult_MessageContextDecodeErrorZ self;
public:
- COption_u32Z(const COption_u32Z&) = delete;
- COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
- COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
- operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
- ~COption_u32Z() { COption_u32Z_free(self); }
- COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
- LDKCOption_u32Z* operator &() { return &self; }
- LDKCOption_u32Z* operator ->() { return &self; }
- const LDKCOption_u32Z* operator &() const { return &self; }
- const LDKCOption_u32Z* operator ->() const { return &self; }
+ CResult_MessageContextDecodeErrorZ(const CResult_MessageContextDecodeErrorZ&) = delete;
+ CResult_MessageContextDecodeErrorZ(CResult_MessageContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MessageContextDecodeErrorZ)); }
+ CResult_MessageContextDecodeErrorZ(LDKCResult_MessageContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MessageContextDecodeErrorZ)); }
+ operator LDKCResult_MessageContextDecodeErrorZ() && { LDKCResult_MessageContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MessageContextDecodeErrorZ)); return res; }
+ ~CResult_MessageContextDecodeErrorZ() { CResult_MessageContextDecodeErrorZ_free(self); }
+ CResult_MessageContextDecodeErrorZ& operator=(CResult_MessageContextDecodeErrorZ&& o) { CResult_MessageContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MessageContextDecodeErrorZ)); return *this; }
+ LDKCResult_MessageContextDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_MessageContextDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_MessageContextDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_MessageContextDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_InitFeaturesDecodeErrorZ {
private:
const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
-private:
- LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
-public:
- CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
- CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
- CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
- operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
- ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
- CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
- LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
- LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_PaymentIdPaymentSendFailureZ {
-private:
- LDKCResult_PaymentIdPaymentSendFailureZ self;
-public:
- CResult_PaymentIdPaymentSendFailureZ(const CResult_PaymentIdPaymentSendFailureZ&) = delete;
- CResult_PaymentIdPaymentSendFailureZ(CResult_PaymentIdPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); }
- CResult_PaymentIdPaymentSendFailureZ(LDKCResult_PaymentIdPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); }
- operator LDKCResult_PaymentIdPaymentSendFailureZ() && { LDKCResult_PaymentIdPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentSendFailureZ)); return res; }
- ~CResult_PaymentIdPaymentSendFailureZ() { CResult_PaymentIdPaymentSendFailureZ_free(self); }
- CResult_PaymentIdPaymentSendFailureZ& operator=(CResult_PaymentIdPaymentSendFailureZ&& o) { CResult_PaymentIdPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentSendFailureZ)); return *this; }
- LDKCResult_PaymentIdPaymentSendFailureZ* operator &() { return &self; }
- LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() { return &self; }
- const LDKCResult_PaymentIdPaymentSendFailureZ* operator &() const { return &self; }
- const LDKCResult_PaymentIdPaymentSendFailureZ* operator ->() const { return &self; }
-};
-class CResult_OnionMessageDecodeErrorZ {
-private:
- LDKCResult_OnionMessageDecodeErrorZ self;
-public:
- CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
- CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
- CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
- operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
- ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
- CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
- LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
- LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_CommitmentTransactionDecodeErrorZ {
-private:
- LDKCResult_CommitmentTransactionDecodeErrorZ self;
-public:
- CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
- CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
- CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
- operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
- ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
- CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
- LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
- LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_TransactionNoneZ {
-private:
- LDKCResult_TransactionNoneZ self;
-public:
- CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
- CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
- CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
- operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
- ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
- CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
- LDKCResult_TransactionNoneZ* operator &() { return &self; }
- LDKCResult_TransactionNoneZ* operator ->() { return &self; }
- const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
- const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
-};
-class CResult_ClosingSignedFeeRangeDecodeErrorZ {
+class CResult_PublicKeyNoneZ {
private:
- LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
+ LDKCResult_PublicKeyNoneZ self;
public:
- CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
- CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
- CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
- operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
- ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
- CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
- LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
+ CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
+ CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
+ CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
+ operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
+ ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
+ CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
+ LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
+ LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
+ const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
+ const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
};
class CResult_PingDecodeErrorZ {
private:
const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
-private:
- LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
-public:
- CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
- CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
- CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
- operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
- ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
- CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
- LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_ReplyChannelRangeDecodeErrorZ {
-private:
- LDKCResult_ReplyChannelRangeDecodeErrorZ self;
-public:
- CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
- CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
- CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
- operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
- ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
- CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
- LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_GossipTimestampFilterDecodeErrorZ {
-private:
- LDKCResult_GossipTimestampFilterDecodeErrorZ self;
-public:
- CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
- CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
- CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
- operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
- ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
- CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
- LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
- LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_InvoiceSignOrCreationErrorZ {
-private:
- LDKCResult_InvoiceSignOrCreationErrorZ self;
-public:
- CResult_InvoiceSignOrCreationErrorZ(const CResult_InvoiceSignOrCreationErrorZ&) = delete;
- CResult_InvoiceSignOrCreationErrorZ(CResult_InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); }
- CResult_InvoiceSignOrCreationErrorZ(LDKCResult_InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); }
- operator LDKCResult_InvoiceSignOrCreationErrorZ() && { LDKCResult_InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSignOrCreationErrorZ)); return res; }
- ~CResult_InvoiceSignOrCreationErrorZ() { CResult_InvoiceSignOrCreationErrorZ_free(self); }
- CResult_InvoiceSignOrCreationErrorZ& operator=(CResult_InvoiceSignOrCreationErrorZ&& o) { CResult_InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSignOrCreationErrorZ)); return *this; }
- LDKCResult_InvoiceSignOrCreationErrorZ* operator &() { return &self; }
- LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
- const LDKCResult_InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
- const LDKCResult_InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
+class CResult_RevocationKeyDecodeErrorZ {
+private:
+ LDKCResult_RevocationKeyDecodeErrorZ self;
+public:
+ CResult_RevocationKeyDecodeErrorZ(const CResult_RevocationKeyDecodeErrorZ&) = delete;
+ CResult_RevocationKeyDecodeErrorZ(CResult_RevocationKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); }
+ CResult_RevocationKeyDecodeErrorZ(LDKCResult_RevocationKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); }
+ operator LDKCResult_RevocationKeyDecodeErrorZ() && { LDKCResult_RevocationKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); return res; }
+ ~CResult_RevocationKeyDecodeErrorZ() { CResult_RevocationKeyDecodeErrorZ_free(self); }
+ CResult_RevocationKeyDecodeErrorZ& operator=(CResult_RevocationKeyDecodeErrorZ&& o) { CResult_RevocationKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); return *this; }
+ LDKCResult_RevocationKeyDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RevocationKeyDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RevocationKeyDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RevocationKeyDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_OffersMessageMessageSendInstructionsZ {
+private:
+ LDKC2Tuple_OffersMessageMessageSendInstructionsZ self;
+public:
+ C2Tuple_OffersMessageMessageSendInstructionsZ(const C2Tuple_OffersMessageMessageSendInstructionsZ&) = delete;
+ C2Tuple_OffersMessageMessageSendInstructionsZ(C2Tuple_OffersMessageMessageSendInstructionsZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OffersMessageMessageSendInstructionsZ)); }
+ C2Tuple_OffersMessageMessageSendInstructionsZ(LDKC2Tuple_OffersMessageMessageSendInstructionsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OffersMessageMessageSendInstructionsZ)); }
+ operator LDKC2Tuple_OffersMessageMessageSendInstructionsZ() && { LDKC2Tuple_OffersMessageMessageSendInstructionsZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OffersMessageMessageSendInstructionsZ)); return res; }
+ ~C2Tuple_OffersMessageMessageSendInstructionsZ() { C2Tuple_OffersMessageMessageSendInstructionsZ_free(self); }
+ C2Tuple_OffersMessageMessageSendInstructionsZ& operator=(C2Tuple_OffersMessageMessageSendInstructionsZ&& o) { C2Tuple_OffersMessageMessageSendInstructionsZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OffersMessageMessageSendInstructionsZ)); return *this; }
+ LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator &() { return &self; }
+ LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator ->() { return &self; }
+ const LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator &() const { return &self; }
+ const LDKC2Tuple_OffersMessageMessageSendInstructionsZ* operator ->() const { return &self; }
+};
+class CResult_BlindedHopFeaturesDecodeErrorZ {
+private:
+ LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
+public:
+ CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
+ CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
+ CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
+ operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
+ ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
+ CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelIdDecodeErrorZ {
+private:
+ LDKCResult_ChannelIdDecodeErrorZ self;
+public:
+ CResult_ChannelIdDecodeErrorZ(const CResult_ChannelIdDecodeErrorZ&) = delete;
+ CResult_ChannelIdDecodeErrorZ(CResult_ChannelIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelIdDecodeErrorZ)); }
+ CResult_ChannelIdDecodeErrorZ(LDKCResult_ChannelIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelIdDecodeErrorZ)); }
+ operator LDKCResult_ChannelIdDecodeErrorZ() && { LDKCResult_ChannelIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelIdDecodeErrorZ)); return res; }
+ ~CResult_ChannelIdDecodeErrorZ() { CResult_ChannelIdDecodeErrorZ_free(self); }
+ CResult_ChannelIdDecodeErrorZ& operator=(CResult_ChannelIdDecodeErrorZ&& o) { CResult_ChannelIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelIdDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelIdDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelIdDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelIdDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelIdDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_TransactionOutputsZ {
private:
~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
LDKCVec_TransactionOutputsZ* operator &() { return &self; }
- LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
- const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
- const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
-};
-class CResult_ErrorMessageDecodeErrorZ {
-private:
- LDKCResult_ErrorMessageDecodeErrorZ self;
-public:
- CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
- CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
- CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
- operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
- ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
- CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
- LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_OpenChannelDecodeErrorZ {
-private:
- LDKCResult_OpenChannelDecodeErrorZ self;
-public:
- CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
- CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
- CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
- operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
- ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
- CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
- LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
- LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_CVec_u8ZZ {
-private:
- LDKCVec_CVec_u8ZZ self;
-public:
- CVec_CVec_u8ZZ(const CVec_CVec_u8ZZ&) = delete;
- CVec_CVec_u8ZZ(CVec_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); }
- CVec_CVec_u8ZZ(LDKCVec_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_u8ZZ)); }
- operator LDKCVec_CVec_u8ZZ() && { LDKCVec_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_u8ZZ)); return res; }
- ~CVec_CVec_u8ZZ() { CVec_CVec_u8ZZ_free(self); }
- CVec_CVec_u8ZZ& operator=(CVec_CVec_u8ZZ&& o) { CVec_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); return *this; }
- LDKCVec_CVec_u8ZZ* operator &() { return &self; }
- LDKCVec_CVec_u8ZZ* operator ->() { return &self; }
- const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
- const LDKCVec_CVec_u8ZZ* 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 CResult_SecretKeyErrorZ {
-private:
- LDKCResult_SecretKeyErrorZ self;
-public:
- CResult_SecretKeyErrorZ(const CResult_SecretKeyErrorZ&) = delete;
- CResult_SecretKeyErrorZ(CResult_SecretKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyErrorZ)); }
- CResult_SecretKeyErrorZ(LDKCResult_SecretKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyErrorZ)); }
- operator LDKCResult_SecretKeyErrorZ() && { LDKCResult_SecretKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyErrorZ)); return res; }
- ~CResult_SecretKeyErrorZ() { CResult_SecretKeyErrorZ_free(self); }
- CResult_SecretKeyErrorZ& operator=(CResult_SecretKeyErrorZ&& o) { CResult_SecretKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyErrorZ)); return *this; }
- LDKCResult_SecretKeyErrorZ* operator &() { return &self; }
- LDKCResult_SecretKeyErrorZ* operator ->() { return &self; }
- const LDKCResult_SecretKeyErrorZ* operator &() const { return &self; }
- const LDKCResult_SecretKeyErrorZ* operator ->() const { return &self; }
-};
-class CResult_ShutdownScriptDecodeErrorZ {
-private:
- LDKCResult_ShutdownScriptDecodeErrorZ self;
-public:
- CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
- CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
- CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
- operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
- ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
- CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
- LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
+ LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
+ const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
+ const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
+};
+class COption_HTLCClaimZ {
+private:
+ LDKCOption_HTLCClaimZ self;
+public:
+ COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
+ COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
+ COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
+ operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
+ ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
+ COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
+ LDKCOption_HTLCClaimZ* operator &() { return &self; }
+ LDKCOption_HTLCClaimZ* operator ->() { return &self; }
+ const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
+ const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
+};
+class COption_boolZ {
+private:
+ LDKCOption_boolZ self;
+public:
+ COption_boolZ(const COption_boolZ&) = delete;
+ COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
+ COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
+ operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
+ ~COption_boolZ() { COption_boolZ_free(self); }
+ COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
+ LDKCOption_boolZ* operator &() { return &self; }
+ LDKCOption_boolZ* operator ->() { return &self; }
+ const LDKCOption_boolZ* operator &() const { return &self; }
+ const LDKCOption_boolZ* operator ->() const { return &self; }
+};
+class CVec_BlindedPaymentPathZ {
+private:
+ LDKCVec_BlindedPaymentPathZ self;
+public:
+ CVec_BlindedPaymentPathZ(const CVec_BlindedPaymentPathZ&) = delete;
+ CVec_BlindedPaymentPathZ(CVec_BlindedPaymentPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPaymentPathZ)); }
+ CVec_BlindedPaymentPathZ(LDKCVec_BlindedPaymentPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPaymentPathZ)); }
+ operator LDKCVec_BlindedPaymentPathZ() && { LDKCVec_BlindedPaymentPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPaymentPathZ)); return res; }
+ ~CVec_BlindedPaymentPathZ() { CVec_BlindedPaymentPathZ_free(self); }
+ CVec_BlindedPaymentPathZ& operator=(CVec_BlindedPaymentPathZ&& o) { CVec_BlindedPaymentPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPaymentPathZ)); return *this; }
+ LDKCVec_BlindedPaymentPathZ* operator &() { return &self; }
+ LDKCVec_BlindedPaymentPathZ* operator ->() { return &self; }
+ const LDKCVec_BlindedPaymentPathZ* operator &() const { return &self; }
+ const LDKCVec_BlindedPaymentPathZ* operator ->() const { return &self; }
};
class CResult_ProbabilisticScorerDecodeErrorZ {
private:
const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_QueryChannelRangeDecodeErrorZ {
-private:
- LDKCResult_QueryChannelRangeDecodeErrorZ self;
-public:
- CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
- CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
- CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
- operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
- ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
- CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
- LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
- LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_TxCreationKeysDecodeErrorZ {
-private:
- LDKCResult_TxCreationKeysDecodeErrorZ self;
-public:
- CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
- CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
- CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
- operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
- ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
- CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
- LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
- LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
+class COption_StrZ {
+private:
+ LDKCOption_StrZ self;
+public:
+ COption_StrZ(const COption_StrZ&) = delete;
+ COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
+ COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
+ operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
+ ~COption_StrZ() { COption_StrZ_free(self); }
+ COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
+ LDKCOption_StrZ* operator &() { return &self; }
+ LDKCOption_StrZ* operator ->() { return &self; }
+ const LDKCOption_StrZ* operator &() const { return &self; }
+ const LDKCOption_StrZ* operator ->() const { return &self; }
+};
+class CResult_CVec_BlindedPaymentPathZNoneZ {
+private:
+ LDKCResult_CVec_BlindedPaymentPathZNoneZ self;
+public:
+ CResult_CVec_BlindedPaymentPathZNoneZ(const CResult_CVec_BlindedPaymentPathZNoneZ&) = delete;
+ CResult_CVec_BlindedPaymentPathZNoneZ(CResult_CVec_BlindedPaymentPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedPaymentPathZNoneZ)); }
+ CResult_CVec_BlindedPaymentPathZNoneZ(LDKCResult_CVec_BlindedPaymentPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedPaymentPathZNoneZ)); }
+ operator LDKCResult_CVec_BlindedPaymentPathZNoneZ() && { LDKCResult_CVec_BlindedPaymentPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedPaymentPathZNoneZ)); return res; }
+ ~CResult_CVec_BlindedPaymentPathZNoneZ() { CResult_CVec_BlindedPaymentPathZNoneZ_free(self); }
+ CResult_CVec_BlindedPaymentPathZNoneZ& operator=(CResult_CVec_BlindedPaymentPathZNoneZ&& o) { CResult_CVec_BlindedPaymentPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedPaymentPathZNoneZ)); return *this; }
+ LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator &() { return &self; }
+ LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator ->() { return &self; }
+ const LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator &() const { return &self; }
+ const LDKCResult_CVec_BlindedPaymentPathZNoneZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_OffersMessageResponseInstructionZZ {
+private:
+ LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ self;
+public:
+ COption_C2Tuple_OffersMessageResponseInstructionZZ(const COption_C2Tuple_OffersMessageResponseInstructionZZ&) = delete;
+ COption_C2Tuple_OffersMessageResponseInstructionZZ(COption_C2Tuple_OffersMessageResponseInstructionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_OffersMessageResponseInstructionZZ)); }
+ COption_C2Tuple_OffersMessageResponseInstructionZZ(LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ)); }
+ operator LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ() && { LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ)); return res; }
+ ~COption_C2Tuple_OffersMessageResponseInstructionZZ() { COption_C2Tuple_OffersMessageResponseInstructionZZ_free(self); }
+ COption_C2Tuple_OffersMessageResponseInstructionZZ& operator=(COption_C2Tuple_OffersMessageResponseInstructionZZ&& o) { COption_C2Tuple_OffersMessageResponseInstructionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_OffersMessageResponseInstructionZZ)); return *this; }
+ LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator &() { return &self; }
+ LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator ->() { return &self; }
+ const LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator &() const { return &self; }
+ const LDKCOption_C2Tuple_OffersMessageResponseInstructionZZ* operator ->() const { return &self; }
};
class C2Tuple_usizeTransactionZ {
private:
const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
};
-class CResult_ChannelFeaturesDecodeErrorZ {
+class COption_OffersContextZ {
private:
- LDKCResult_ChannelFeaturesDecodeErrorZ self;
+ LDKCOption_OffersContextZ self;
public:
- CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
- CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
- CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
- operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
- ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
- CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
- LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
+ COption_OffersContextZ(const COption_OffersContextZ&) = delete;
+ COption_OffersContextZ(COption_OffersContextZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersContextZ)); }
+ COption_OffersContextZ(LDKCOption_OffersContextZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersContextZ)); }
+ operator LDKCOption_OffersContextZ() && { LDKCOption_OffersContextZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersContextZ)); return res; }
+ ~COption_OffersContextZ() { COption_OffersContextZ_free(self); }
+ COption_OffersContextZ& operator=(COption_OffersContextZ&& o) { COption_OffersContextZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersContextZ)); return *this; }
+ LDKCOption_OffersContextZ* operator &() { return &self; }
+ LDKCOption_OffersContextZ* operator ->() { return &self; }
+ const LDKCOption_OffersContextZ* operator &() const { return &self; }
+ const LDKCOption_OffersContextZ* operator ->() const { return &self; }
+};
+class CResult_NodeAnnouncementDecodeErrorZ {
+private:
+ LDKCResult_NodeAnnouncementDecodeErrorZ self;
+public:
+ CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
+ CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
+ CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
+ operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
+ ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
+ CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
+ LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_ChannelMonitorZ {
private:
const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
};
-class CVec_TransactionZ {
+class CResult_AcceptChannelV2DecodeErrorZ {
private:
- LDKCVec_TransactionZ self;
+ LDKCResult_AcceptChannelV2DecodeErrorZ self;
public:
- CVec_TransactionZ(const CVec_TransactionZ&) = delete;
- CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
- CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
- operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
- ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
- CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
- LDKCVec_TransactionZ* operator &() { return &self; }
- LDKCVec_TransactionZ* operator ->() { return &self; }
- const LDKCVec_TransactionZ* operator &() const { return &self; }
- const LDKCVec_TransactionZ* operator ->() const { return &self; }
+ CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
+ CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
+ CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
+ operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
+ ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
+ CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
+ LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
+ LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_ChannelReadyDecodeErrorZ {
+class CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ {
private:
- LDKCResult_ChannelReadyDecodeErrorZ self;
+ LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ self;
public:
- CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
- CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
- CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
- operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
- ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
- CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
- LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
+ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ(const CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&) = delete;
+ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); }
+ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); }
+ operator LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ() && { LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); return res; }
+ ~CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ() { CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(self); }
+ CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ& operator=(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ&& o) { CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_InboundHTLCStateDetailsZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_InboundHTLCStateDetailsZDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_RouteHopDecodeErrorZ {
private:
const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_UpdateFeeDecodeErrorZ {
-private:
- LDKCResult_UpdateFeeDecodeErrorZ self;
-public:
- CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
- CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
- CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
- operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
- ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
- CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
- LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
+class CResult_OfferIdDecodeErrorZ {
+private:
+ LDKCResult_OfferIdDecodeErrorZ self;
+public:
+ CResult_OfferIdDecodeErrorZ(const CResult_OfferIdDecodeErrorZ&) = delete;
+ CResult_OfferIdDecodeErrorZ(CResult_OfferIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferIdDecodeErrorZ)); }
+ CResult_OfferIdDecodeErrorZ(LDKCResult_OfferIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferIdDecodeErrorZ)); }
+ operator LDKCResult_OfferIdDecodeErrorZ() && { LDKCResult_OfferIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferIdDecodeErrorZ)); return res; }
+ ~CResult_OfferIdDecodeErrorZ() { CResult_OfferIdDecodeErrorZ_free(self); }
+ CResult_OfferIdDecodeErrorZ& operator=(CResult_OfferIdDecodeErrorZ&& o) { CResult_OfferIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferIdDecodeErrorZ)); return *this; }
+ LDKCResult_OfferIdDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OfferIdDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OfferIdDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OfferIdDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_HTLCOutputInCommitmentZ {
+private:
+ LDKCVec_HTLCOutputInCommitmentZ self;
+public:
+ CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
+ CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
+ CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
+ operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
+ ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
+ CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
+ LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
+ LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
+ const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
+ const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
+};
+class CResult_CoinSelectionNoneZ {
+private:
+ LDKCResult_CoinSelectionNoneZ self;
+public:
+ CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
+ CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
+ CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
+ operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
+ ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
+ CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
+ LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
+ LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
+ const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
+ const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
+};
+class CVec_FutureZ {
+private:
+ LDKCVec_FutureZ self;
+public:
+ CVec_FutureZ(const CVec_FutureZ&) = delete;
+ CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
+ CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
+ operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
+ ~CVec_FutureZ() { CVec_FutureZ_free(self); }
+ CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
+ LDKCVec_FutureZ* operator &() { return &self; }
+ LDKCVec_FutureZ* operator ->() { return &self; }
+ const LDKCVec_FutureZ* operator &() const { return &self; }
+ const LDKCVec_FutureZ* operator ->() const { return &self; }
};
-class CResult_NodeAnnouncementDecodeErrorZ {
+class CResult_TxCreationKeysDecodeErrorZ {
private:
- LDKCResult_NodeAnnouncementDecodeErrorZ self;
+ LDKCResult_TxCreationKeysDecodeErrorZ self;
public:
- CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
- CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
- CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
- operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
- ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
- CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
- LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
- LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
+ CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
+ CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
+ CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
+ operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
+ ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
+ CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
+ LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_RefundBolt12SemanticErrorZ {
+private:
+ LDKCResult_RefundBolt12SemanticErrorZ self;
+public:
+ CResult_RefundBolt12SemanticErrorZ(const CResult_RefundBolt12SemanticErrorZ&) = delete;
+ CResult_RefundBolt12SemanticErrorZ(CResult_RefundBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12SemanticErrorZ)); }
+ CResult_RefundBolt12SemanticErrorZ(LDKCResult_RefundBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12SemanticErrorZ)); }
+ operator LDKCResult_RefundBolt12SemanticErrorZ() && { LDKCResult_RefundBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12SemanticErrorZ)); return res; }
+ ~CResult_RefundBolt12SemanticErrorZ() { CResult_RefundBolt12SemanticErrorZ_free(self); }
+ CResult_RefundBolt12SemanticErrorZ& operator=(CResult_RefundBolt12SemanticErrorZ&& o) { CResult_RefundBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_RefundBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_RefundBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_RefundBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_RefundBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_NoneIOErrorZ {
+private:
+ LDKCResult_NoneIOErrorZ self;
+public:
+ CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
+ CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
+ CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
+ operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
+ ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
+ CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
+ LDKCResult_NoneIOErrorZ* operator &() { return &self; }
+ LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
+ const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
+ const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
+};
+class CResult_MaxDustHTLCExposureDecodeErrorZ {
+private:
+ LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
+public:
+ CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
+ CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
+ CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
+ operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
+ ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
+ CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
+ LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_BalanceZ {
private:
const LDKCVec_BalanceZ* operator &() const { return &self; }
const LDKCVec_BalanceZ* operator ->() const { return &self; }
};
-class CResult_HTLCOutputInCommitmentDecodeErrorZ {
-private:
- LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
-public:
- CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
- CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
- CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
- operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
- ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
- CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
- LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
- LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_boolLightningErrorZ {
-private:
- LDKCResult_boolLightningErrorZ self;
-public:
- CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
- CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
- CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
- operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
- ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
- CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
- LDKCResult_boolLightningErrorZ* operator &() { return &self; }
- LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
- const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
- const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
-};
-class CResult_TxCreationKeysErrorZ {
-private:
- LDKCResult_TxCreationKeysErrorZ self;
-public:
- CResult_TxCreationKeysErrorZ(const CResult_TxCreationKeysErrorZ&) = delete;
- CResult_TxCreationKeysErrorZ(CResult_TxCreationKeysErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysErrorZ)); }
- CResult_TxCreationKeysErrorZ(LDKCResult_TxCreationKeysErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysErrorZ)); }
- operator LDKCResult_TxCreationKeysErrorZ() && { LDKCResult_TxCreationKeysErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysErrorZ)); return res; }
- ~CResult_TxCreationKeysErrorZ() { CResult_TxCreationKeysErrorZ_free(self); }
- CResult_TxCreationKeysErrorZ& operator=(CResult_TxCreationKeysErrorZ&& o) { CResult_TxCreationKeysErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysErrorZ)); return *this; }
- LDKCResult_TxCreationKeysErrorZ* operator &() { return &self; }
- LDKCResult_TxCreationKeysErrorZ* operator ->() { return &self; }
- const LDKCResult_TxCreationKeysErrorZ* operator &() const { return &self; }
- const LDKCResult_TxCreationKeysErrorZ* operator ->() const { return &self; }
-};
-class COption_HTLCDestinationZ {
-private:
- LDKCOption_HTLCDestinationZ self;
-public:
- COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
- COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
- COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
- operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
- ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
- COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
- LDKCOption_HTLCDestinationZ* operator &() { return &self; }
- LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
- const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
- const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
-};
-class CResult_NodeIdDecodeErrorZ {
-private:
- LDKCResult_NodeIdDecodeErrorZ self;
-public:
- CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
- CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
- CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
- operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
- ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
- CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
- LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
- LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_ShutdownScriptInvalidShutdownScriptZ {
-private:
- LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
-public:
- CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
- CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
- CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
- operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
- ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
- CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
- LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
- LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
- const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
- const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
-};
-class CResult_NodeAnnouncementInfoDecodeErrorZ {
+class CVec_CommitmentTransactionZ {
private:
- LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
+ LDKCVec_CommitmentTransactionZ self;
public:
- CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
- CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
- CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
- operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
- ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
- CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
- LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
- LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
+ CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
+ CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
+ CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
+ operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
+ ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
+ CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
+ LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
+ LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
+ const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
+ const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
};
-class CResult_COption_NetworkUpdateZDecodeErrorZ {
+class CResult_FundingSignedDecodeErrorZ {
private:
- LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
+ LDKCResult_FundingSignedDecodeErrorZ self;
public:
- CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
- CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
- CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
- operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
- ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
- CResult_COption_NetworkUpdateZDecodeErrorZ& operator=(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); return *this; }
- LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
+ CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
+ CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
+ CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
+ operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
+ ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
+ CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
+ LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_RecoverableSignatureNoneZ {
private:
const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
};
-class C2Tuple_BlockHashChannelMonitorZ {
-private:
- LDKC2Tuple_BlockHashChannelMonitorZ self;
-public:
- C2Tuple_BlockHashChannelMonitorZ(const C2Tuple_BlockHashChannelMonitorZ&) = delete;
- C2Tuple_BlockHashChannelMonitorZ(C2Tuple_BlockHashChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); }
- C2Tuple_BlockHashChannelMonitorZ(LDKC2Tuple_BlockHashChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); }
- operator LDKC2Tuple_BlockHashChannelMonitorZ() && { LDKC2Tuple_BlockHashChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelMonitorZ)); return res; }
- ~C2Tuple_BlockHashChannelMonitorZ() { C2Tuple_BlockHashChannelMonitorZ_free(self); }
- C2Tuple_BlockHashChannelMonitorZ& operator=(C2Tuple_BlockHashChannelMonitorZ&& o) { C2Tuple_BlockHashChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelMonitorZ)); return *this; }
- LDKC2Tuple_BlockHashChannelMonitorZ* operator &() { return &self; }
- LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() { return &self; }
- const LDKC2Tuple_BlockHashChannelMonitorZ* operator &() const { return &self; }
- const LDKC2Tuple_BlockHashChannelMonitorZ* operator ->() const { return &self; }
-};
-class C3Tuple_RawInvoice_u832InvoiceSignatureZ {
+class CResult_SocketAddressDecodeErrorZ {
private:
- LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ self;
-public:
- C3Tuple_RawInvoice_u832InvoiceSignatureZ(const C3Tuple_RawInvoice_u832InvoiceSignatureZ&) = delete;
- C3Tuple_RawInvoice_u832InvoiceSignatureZ(C3Tuple_RawInvoice_u832InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawInvoice_u832InvoiceSignatureZ)); }
- C3Tuple_RawInvoice_u832InvoiceSignatureZ(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ)); }
- operator LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ() && { LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ)); return res; }
- ~C3Tuple_RawInvoice_u832InvoiceSignatureZ() { C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(self); }
- C3Tuple_RawInvoice_u832InvoiceSignatureZ& operator=(C3Tuple_RawInvoice_u832InvoiceSignatureZ&& o) { C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_RawInvoice_u832InvoiceSignatureZ)); return *this; }
- LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() { return &self; }
- LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() { return &self; }
- const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator &() const { return &self; }
- const LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* operator ->() const { return &self; }
-};
-class CVec_UpdateFailMalformedHTLCZ {
-private:
- LDKCVec_UpdateFailMalformedHTLCZ self;
-public:
- CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
- CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
- CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
- operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
- ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
- CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
- LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
- LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
- const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
- const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
+ LDKCResult_SocketAddressDecodeErrorZ self;
+public:
+ CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
+ CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
+ CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
+ operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
+ ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
+ CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
+ LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_FundingSignedDecodeErrorZ {
+class C2Tuple_Z {
private:
- LDKCResult_FundingSignedDecodeErrorZ self;
+ LDKC2Tuple_Z self;
public:
- CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
- CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
- CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
- operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
- ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
- CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
- LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
- LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
+ C2Tuple_Z(const C2Tuple_Z&) = delete;
+ C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
+ C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
+ operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
+ ~C2Tuple_Z() { C2Tuple_Z_free(self); }
+ C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
+ LDKC2Tuple_Z* operator &() { return &self; }
+ LDKC2Tuple_Z* operator ->() { return &self; }
+ const LDKC2Tuple_Z* operator &() const { return &self; }
+ const LDKC2Tuple_Z* operator ->() const { return &self; }
+};
+class CResult_ShutdownScriptDecodeErrorZ {
+private:
+ LDKCResult_ShutdownScriptDecodeErrorZ self;
+public:
+ CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
+ CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
+ CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
+ operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
+ ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
+ CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
+ LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_InboundHTLCDetailsDecodeErrorZ {
+private:
+ LDKCResult_InboundHTLCDetailsDecodeErrorZ self;
+public:
+ CResult_InboundHTLCDetailsDecodeErrorZ(const CResult_InboundHTLCDetailsDecodeErrorZ&) = delete;
+ CResult_InboundHTLCDetailsDecodeErrorZ(CResult_InboundHTLCDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InboundHTLCDetailsDecodeErrorZ)); }
+ CResult_InboundHTLCDetailsDecodeErrorZ(LDKCResult_InboundHTLCDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InboundHTLCDetailsDecodeErrorZ)); }
+ operator LDKCResult_InboundHTLCDetailsDecodeErrorZ() && { LDKCResult_InboundHTLCDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InboundHTLCDetailsDecodeErrorZ)); return res; }
+ ~CResult_InboundHTLCDetailsDecodeErrorZ() { CResult_InboundHTLCDetailsDecodeErrorZ_free(self); }
+ CResult_InboundHTLCDetailsDecodeErrorZ& operator=(CResult_InboundHTLCDetailsDecodeErrorZ&& o) { CResult_InboundHTLCDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InboundHTLCDetailsDecodeErrorZ)); return *this; }
+ LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_InboundHTLCDetailsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SiPrefixBolt11ParseErrorZ {
+private:
+ LDKCResult_SiPrefixBolt11ParseErrorZ self;
+public:
+ CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
+ CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
+ CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
+ operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
+ ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
+ CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
+ LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
+ LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
+ const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
+ const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
+private:
+ LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
+public:
+ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
+ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
+ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
+ operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
+ ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
+ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ& operator=(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return *this; }
+ LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
+ LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
+ const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
+ const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
+};
+class CVec_PathZ {
+private:
+ LDKCVec_PathZ self;
+public:
+ CVec_PathZ(const CVec_PathZ&) = delete;
+ CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
+ CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
+ operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
+ ~CVec_PathZ() { CVec_PathZ_free(self); }
+ CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
+ LDKCVec_PathZ* operator &() { return &self; }
+ LDKCVec_PathZ* operator ->() { return &self; }
+ const LDKCVec_PathZ* operator &() const { return &self; }
+ const LDKCVec_PathZ* operator ->() const { return &self; }
};
class CResult_NetworkGraphDecodeErrorZ {
private:
const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_RouteHopZ {
-private:
- LDKCVec_RouteHopZ self;
-public:
- CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
- CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
- CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
- operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
- ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
- CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
- LDKCVec_RouteHopZ* operator &() { return &self; }
- LDKCVec_RouteHopZ* operator ->() { return &self; }
- const LDKCVec_RouteHopZ* operator &() const { return &self; }
- const LDKCVec_RouteHopZ* operator ->() const { return &self; }
-};
class CResult_NodeInfoDecodeErrorZ {
private:
LDKCResult_NodeInfoDecodeErrorZ self;
const LDKCVec_NodeIdZ* operator &() const { return &self; }
const LDKCVec_NodeIdZ* operator ->() const { return &self; }
};
-class CResult_RouteLightningErrorZ {
-private:
- LDKCResult_RouteLightningErrorZ self;
-public:
- CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
- CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
- CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
- operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
- ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
- CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
- LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
- LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
- const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
- const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
-};
-class CResult_ChannelPublicKeysDecodeErrorZ {
-private:
- LDKCResult_ChannelPublicKeysDecodeErrorZ self;
-public:
- CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
- CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
- CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
- operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
- ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
- CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
- LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
-};
class CVec_u8Z {
private:
LDKCVec_u8Z self;
const LDKCVec_u8Z* operator &() const { return &self; }
const LDKCVec_u8Z* operator ->() const { return &self; }
};
-class CVec_C2Tuple_BlockHashChannelMonitorZZ {
+class CResult_RouteLightningErrorZ {
private:
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ self;
+ LDKCResult_RouteLightningErrorZ self;
public:
- CVec_C2Tuple_BlockHashChannelMonitorZZ(const CVec_C2Tuple_BlockHashChannelMonitorZZ&) = delete;
- CVec_C2Tuple_BlockHashChannelMonitorZZ(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); }
- CVec_C2Tuple_BlockHashChannelMonitorZZ(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); }
- operator LDKCVec_C2Tuple_BlockHashChannelMonitorZZ() && { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ)); return res; }
- ~CVec_C2Tuple_BlockHashChannelMonitorZZ() { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); }
- CVec_C2Tuple_BlockHashChannelMonitorZZ& operator=(CVec_C2Tuple_BlockHashChannelMonitorZZ&& o) { CVec_C2Tuple_BlockHashChannelMonitorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlockHashChannelMonitorZZ)); return *this; }
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() { return &self; }
- LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() { return &self; }
- const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator &() const { return &self; }
- const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ* operator ->() const { return &self; }
+ CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
+ CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
+ CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
+ operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
+ ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
+ CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
+ LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
+ LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
+ const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
+ const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
};
class CResult_NonePaymentSendFailureZ {
private:
const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
};
-class CVec_ThirtyTwoBytesZ {
-private:
- LDKCVec_ThirtyTwoBytesZ self;
-public:
- CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
- CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
- CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
- operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
- ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
- CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
- LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
- LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
- const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
- const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
-};
-class CResult_ClosingSignedDecodeErrorZ {
-private:
- LDKCResult_ClosingSignedDecodeErrorZ self;
-public:
- CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
- CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
- CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
- operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
- ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
- CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
- LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_CResult_NoneAPIErrorZZ {
-private:
- LDKCVec_CResult_NoneAPIErrorZZ self;
-public:
- CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
- CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
- CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
- operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
- ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
- CVec_CResult_NoneAPIErrorZZ& operator=(CVec_CResult_NoneAPIErrorZZ&& o) { CVec_CResult_NoneAPIErrorZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); return *this; }
- LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
- LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
- const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
- const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
-};
-class CResult_HolderCommitmentTransactionDecodeErrorZ {
+class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
private:
- LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
public:
- CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
- CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
- CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
- operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
- ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
- CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
- LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
- LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
+ operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
+ ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return *this; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
+class CResult_ChannelPublicKeysDecodeErrorZ {
private:
- LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
+ LDKCResult_ChannelPublicKeysDecodeErrorZ self;
public:
- CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
- CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
- CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
- operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
- ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
- CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
- LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
- LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
+ CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
+ CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
+ CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
+ operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
+ ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
+ CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_ChannelCounterpartyDecodeErrorZ {
-private:
- LDKCResult_ChannelCounterpartyDecodeErrorZ self;
-public:
- CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
- CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
- CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
- operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
- ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
- CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
- LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
+class CVec_ClaimedHTLCZ {
+private:
+ LDKCVec_ClaimedHTLCZ self;
+public:
+ CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
+ CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
+ CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
+ operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
+ ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
+ CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
+ LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
+ LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
+ const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
+ const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
+};
+class COption_CVec_ThirtyTwoBytesZZ {
+private:
+ LDKCOption_CVec_ThirtyTwoBytesZZ self;
+public:
+ COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
+ COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
+ COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
+ operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
+ ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
+ COption_CVec_ThirtyTwoBytesZZ& operator=(COption_CVec_ThirtyTwoBytesZZ&& o) { COption_CVec_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); return *this; }
+ LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
+ LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
+ const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
+ const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
+};
+class CVec_SocketAddressZ {
+private:
+ LDKCVec_SocketAddressZ self;
+public:
+ CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
+ CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
+ CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
+ operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
+ ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
+ CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
+ LDKCVec_SocketAddressZ* operator &() { return &self; }
+ LDKCVec_SocketAddressZ* operator ->() { return &self; }
+ const LDKCVec_SocketAddressZ* operator &() const { return &self; }
+ const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
+};
+class CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ {
+private:
+ LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ self;
+public:
+ CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(const CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&) = delete;
+ CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); }
+ CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); }
+ operator LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); return res; }
+ ~CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ() { CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(self); }
+ CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ)); return *this; }
+ LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
+ LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
+ const LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
+ const LDKCVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
+};
+class CResult_ThirtyTwoBytesPaymentSendFailureZ {
+private:
+ LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
+public:
+ CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
+ CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
+ CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
+ operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
+ ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
+ CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
+ LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
+ LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
};
class CResult_WarningMessageDecodeErrorZ {
private:
const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_SignatureNoneZ {
+class CResult_ChannelCounterpartyDecodeErrorZ {
private:
- LDKCResult_SignatureNoneZ self;
+ LDKCResult_ChannelCounterpartyDecodeErrorZ self;
public:
- CResult_SignatureNoneZ(const CResult_SignatureNoneZ&) = delete;
- CResult_SignatureNoneZ(CResult_SignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignatureNoneZ)); }
- CResult_SignatureNoneZ(LDKCResult_SignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignatureNoneZ)); }
- operator LDKCResult_SignatureNoneZ() && { LDKCResult_SignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SignatureNoneZ)); return res; }
- ~CResult_SignatureNoneZ() { CResult_SignatureNoneZ_free(self); }
- CResult_SignatureNoneZ& operator=(CResult_SignatureNoneZ&& o) { CResult_SignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignatureNoneZ)); return *this; }
- LDKCResult_SignatureNoneZ* operator &() { return &self; }
- LDKCResult_SignatureNoneZ* operator ->() { return &self; }
- const LDKCResult_SignatureNoneZ* operator &() const { return &self; }
- const LDKCResult_SignatureNoneZ* operator ->() const { return &self; }
+ CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
+ CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
+ CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
+ operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
+ ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
+ CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_RouteHintHopZ {
+class CResult_HolderCommitmentTransactionDecodeErrorZ {
private:
- LDKCVec_RouteHintHopZ self;
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
public:
- CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
- CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
- CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
- operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
- ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
- CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
- LDKCVec_RouteHintHopZ* operator &() { return &self; }
- LDKCVec_RouteHintHopZ* operator ->() { return &self; }
- const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
- const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
+ CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
+ CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
+ CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
+ operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
+ ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
+ CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_SecretKeyNoneZ {
-private:
- LDKCResult_SecretKeyNoneZ self;
-public:
- CResult_SecretKeyNoneZ(const CResult_SecretKeyNoneZ&) = delete;
- CResult_SecretKeyNoneZ(CResult_SecretKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); }
- CResult_SecretKeyNoneZ(LDKCResult_SecretKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); }
- operator LDKCResult_SecretKeyNoneZ() && { LDKCResult_SecretKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SecretKeyNoneZ)); return res; }
- ~CResult_SecretKeyNoneZ() { CResult_SecretKeyNoneZ_free(self); }
- CResult_SecretKeyNoneZ& operator=(CResult_SecretKeyNoneZ&& o) { CResult_SecretKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SecretKeyNoneZ)); return *this; }
- LDKCResult_SecretKeyNoneZ* operator &() { return &self; }
- LDKCResult_SecretKeyNoneZ* operator ->() { return &self; }
- const LDKCResult_SecretKeyNoneZ* operator &() const { return &self; }
- const LDKCResult_SecretKeyNoneZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ {
-private:
- LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ self;
-public:
- CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(const CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&) = delete;
- CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
- CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); }
- operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return res; }
- ~CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ() { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); }
- CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ)); return *this; }
- LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() { return &self; }
- LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* operator ->() const { return &self; }
-};
-class C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ {
-private:
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ self;
-public:
- C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&) = delete;
- C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); }
- C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); }
- operator LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); return res; }
- ~C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(self); }
- C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ)); return *this; }
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
- LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
- const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
- const LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
+class CResult_DelayedPaymentKeyDecodeErrorZ {
+private:
+ LDKCResult_DelayedPaymentKeyDecodeErrorZ self;
+public:
+ CResult_DelayedPaymentKeyDecodeErrorZ(const CResult_DelayedPaymentKeyDecodeErrorZ&) = delete;
+ CResult_DelayedPaymentKeyDecodeErrorZ(CResult_DelayedPaymentKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); }
+ CResult_DelayedPaymentKeyDecodeErrorZ(LDKCResult_DelayedPaymentKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); }
+ operator LDKCResult_DelayedPaymentKeyDecodeErrorZ() && { LDKCResult_DelayedPaymentKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); return res; }
+ ~CResult_DelayedPaymentKeyDecodeErrorZ() { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); }
+ CResult_DelayedPaymentKeyDecodeErrorZ& operator=(CResult_DelayedPaymentKeyDecodeErrorZ&& o) { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); return *this; }
+ LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() const { return &self; }
+};
+class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ {
+private:
+ LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ self;
+public:
+ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(const C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&) = delete;
+ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
+ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
+ operator LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() && { LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return res; }
+ ~C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); }
+ C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ& operator=(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return *this; }
+ LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() { return &self; }
+ LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() { return &self; }
+ const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() const { return &self; }
+ const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() const { return &self; }
+};
+class CResult_OfferBolt12SemanticErrorZ {
+private:
+ LDKCResult_OfferBolt12SemanticErrorZ self;
+public:
+ CResult_OfferBolt12SemanticErrorZ(const CResult_OfferBolt12SemanticErrorZ&) = delete;
+ CResult_OfferBolt12SemanticErrorZ(CResult_OfferBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12SemanticErrorZ)); }
+ CResult_OfferBolt12SemanticErrorZ(LDKCResult_OfferBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12SemanticErrorZ)); }
+ operator LDKCResult_OfferBolt12SemanticErrorZ() && { LDKCResult_OfferBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12SemanticErrorZ)); return res; }
+ ~CResult_OfferBolt12SemanticErrorZ() { CResult_OfferBolt12SemanticErrorZ_free(self); }
+ CResult_OfferBolt12SemanticErrorZ& operator=(CResult_OfferBolt12SemanticErrorZ&& o) { CResult_OfferBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_OfferBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_OfferBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_OfferBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_OfferBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
+private:
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
+public:
+ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
+ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
+ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
+ operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
+ ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
+ CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return *this; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_PaymentParametersDecodeErrorZ {
+class CResult_InitDecodeErrorZ {
private:
- LDKCResult_PaymentParametersDecodeErrorZ self;
+ LDKCResult_InitDecodeErrorZ self;
public:
- CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
- CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
- CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
- operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
- ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
- CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
- LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
- LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
+ CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
+ CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
+ CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
+ operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
+ ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
+ CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
+ LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_PaymentPurposeDecodeErrorZ {
private:
const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_InitDecodeErrorZ {
-private:
- LDKCResult_InitDecodeErrorZ self;
-public:
- CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
- CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
- CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
- operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
- ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
- CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
- LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
- LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
-};
+class CResult_ClaimedHTLCDecodeErrorZ {
+private:
+ LDKCResult_ClaimedHTLCDecodeErrorZ self;
+public:
+ CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
+ CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
+ CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
+ operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
+ ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
+ CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
+ LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
+};
class CResult_OutPointDecodeErrorZ {
private:
LDKCResult_OutPointDecodeErrorZ self;
const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_BlindedRouteDecodeErrorZ {
-private:
- LDKCResult_BlindedRouteDecodeErrorZ self;
-public:
- CResult_BlindedRouteDecodeErrorZ(const CResult_BlindedRouteDecodeErrorZ&) = delete;
- CResult_BlindedRouteDecodeErrorZ(CResult_BlindedRouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedRouteDecodeErrorZ)); }
- CResult_BlindedRouteDecodeErrorZ(LDKCResult_BlindedRouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedRouteDecodeErrorZ)); }
- operator LDKCResult_BlindedRouteDecodeErrorZ() && { LDKCResult_BlindedRouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedRouteDecodeErrorZ)); return res; }
- ~CResult_BlindedRouteDecodeErrorZ() { CResult_BlindedRouteDecodeErrorZ_free(self); }
- CResult_BlindedRouteDecodeErrorZ& operator=(CResult_BlindedRouteDecodeErrorZ&& o) { CResult_BlindedRouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedRouteDecodeErrorZ)); return *this; }
- LDKCResult_BlindedRouteDecodeErrorZ* operator &() { return &self; }
- LDKCResult_BlindedRouteDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_BlindedRouteDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_BlindedRouteDecodeErrorZ* operator ->() const { return &self; }
-};
class CVec_ChannelDetailsZ {
private:
LDKCVec_ChannelDetailsZ self;
const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
};
+class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
+private:
+ LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
+public:
+ CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
+ CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
+ CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
+ operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
+ ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
+ CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
+ LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
class CVec_MessageSendEventZ {
private:
LDKCVec_MessageSendEventZ self;
const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
};
-class CResult_SignDecodeErrorZ {
-private:
- LDKCResult_SignDecodeErrorZ self;
-public:
- CResult_SignDecodeErrorZ(const CResult_SignDecodeErrorZ&) = delete;
- CResult_SignDecodeErrorZ(CResult_SignDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); }
- CResult_SignDecodeErrorZ(LDKCResult_SignDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); }
- operator LDKCResult_SignDecodeErrorZ() && { LDKCResult_SignDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignDecodeErrorZ)); return res; }
- ~CResult_SignDecodeErrorZ() { CResult_SignDecodeErrorZ_free(self); }
- CResult_SignDecodeErrorZ& operator=(CResult_SignDecodeErrorZ&& o) { CResult_SignDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignDecodeErrorZ)); return *this; }
- LDKCResult_SignDecodeErrorZ* operator &() { return &self; }
- LDKCResult_SignDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_SignDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_SignDecodeErrorZ* operator ->() const { return &self; }
-};
-class COption_NetAddressZ {
-private:
- LDKCOption_NetAddressZ self;
-public:
- COption_NetAddressZ(const COption_NetAddressZ&) = delete;
- COption_NetAddressZ(COption_NetAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetAddressZ)); }
- COption_NetAddressZ(LDKCOption_NetAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetAddressZ)); }
- operator LDKCOption_NetAddressZ() && { LDKCOption_NetAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_NetAddressZ)); return res; }
- ~COption_NetAddressZ() { COption_NetAddressZ_free(self); }
- COption_NetAddressZ& operator=(COption_NetAddressZ&& o) { COption_NetAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetAddressZ)); return *this; }
- LDKCOption_NetAddressZ* operator &() { return &self; }
- LDKCOption_NetAddressZ* operator ->() { return &self; }
- const LDKCOption_NetAddressZ* operator &() const { return &self; }
- const LDKCOption_NetAddressZ* operator ->() const { return &self; }
-};
-class C2Tuple_OutPointScriptZ {
-private:
- LDKC2Tuple_OutPointScriptZ self;
-public:
- C2Tuple_OutPointScriptZ(const C2Tuple_OutPointScriptZ&) = delete;
- C2Tuple_OutPointScriptZ(C2Tuple_OutPointScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); }
- C2Tuple_OutPointScriptZ(LDKC2Tuple_OutPointScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); }
- operator LDKC2Tuple_OutPointScriptZ() && { LDKC2Tuple_OutPointScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointScriptZ)); return res; }
- ~C2Tuple_OutPointScriptZ() { C2Tuple_OutPointScriptZ_free(self); }
- C2Tuple_OutPointScriptZ& operator=(C2Tuple_OutPointScriptZ&& o) { C2Tuple_OutPointScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointScriptZ)); return *this; }
- LDKC2Tuple_OutPointScriptZ* operator &() { return &self; }
- LDKC2Tuple_OutPointScriptZ* operator ->() { return &self; }
- const LDKC2Tuple_OutPointScriptZ* operator &() const { return &self; }
- const LDKC2Tuple_OutPointScriptZ* operator ->() const { return &self; }
+class CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ {
+private:
+ LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ self;
+public:
+ CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ(const CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&) = delete;
+ CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); }
+ CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ(LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); }
+ operator LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ() && { LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); return res; }
+ ~CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ() { CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ_free(self); }
+ CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ& operator=(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ&& o) { CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ)); return *this; }
+ LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ* operator ->() const { return &self; }
};
class CResult_RouteHintHopDecodeErrorZ {
private:
const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_C2Tuple_SignatureSignatureZNoneZ {
+class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ {
private:
- LDKCResult_C2Tuple_SignatureSignatureZNoneZ self;
+ LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ self;
public:
- CResult_C2Tuple_SignatureSignatureZNoneZ(const CResult_C2Tuple_SignatureSignatureZNoneZ&) = delete;
- CResult_C2Tuple_SignatureSignatureZNoneZ(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); }
- CResult_C2Tuple_SignatureSignatureZNoneZ(LDKCResult_C2Tuple_SignatureSignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); }
- operator LDKCResult_C2Tuple_SignatureSignatureZNoneZ() && { LDKCResult_C2Tuple_SignatureSignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ)); return res; }
- ~CResult_C2Tuple_SignatureSignatureZNoneZ() { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); }
- CResult_C2Tuple_SignatureSignatureZNoneZ& operator=(CResult_C2Tuple_SignatureSignatureZNoneZ&& o) { CResult_C2Tuple_SignatureSignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureSignatureZNoneZ)); return *this; }
- LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() { return &self; }
- LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_SignatureSignatureZNoneZ* operator ->() const { return &self; }
+ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(const CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&) = delete;
+ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
+ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
+ operator LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() && { LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return res; }
+ ~CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); }
+ CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ& operator=(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return *this; }
+ LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() { return &self; }
+ LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() { return &self; }
+ const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() const { return &self; }
+ const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() const { return &self; }
};
class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
private:
const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_SharedSecretNoneZ {
-private:
- LDKCResult_SharedSecretNoneZ self;
-public:
- CResult_SharedSecretNoneZ(const CResult_SharedSecretNoneZ&) = delete;
- CResult_SharedSecretNoneZ(CResult_SharedSecretNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SharedSecretNoneZ)); }
- CResult_SharedSecretNoneZ(LDKCResult_SharedSecretNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SharedSecretNoneZ)); }
- operator LDKCResult_SharedSecretNoneZ() && { LDKCResult_SharedSecretNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SharedSecretNoneZ)); return res; }
- ~CResult_SharedSecretNoneZ() { CResult_SharedSecretNoneZ_free(self); }
- CResult_SharedSecretNoneZ& operator=(CResult_SharedSecretNoneZ&& o) { CResult_SharedSecretNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SharedSecretNoneZ)); return *this; }
- LDKCResult_SharedSecretNoneZ* operator &() { return &self; }
- LDKCResult_SharedSecretNoneZ* operator ->() { return &self; }
- const LDKCResult_SharedSecretNoneZ* operator &() const { return &self; }
- const LDKCResult_SharedSecretNoneZ* operator ->() const { return &self; }
-};
-class CVec_TxidZ {
-private:
- LDKCVec_TxidZ self;
-public:
- CVec_TxidZ(const CVec_TxidZ&) = delete;
- CVec_TxidZ(CVec_TxidZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxidZ)); }
- CVec_TxidZ(LDKCVec_TxidZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxidZ)); }
- operator LDKCVec_TxidZ() && { LDKCVec_TxidZ res = self; memset(&self, 0, sizeof(LDKCVec_TxidZ)); return res; }
- ~CVec_TxidZ() { CVec_TxidZ_free(self); }
- CVec_TxidZ& operator=(CVec_TxidZ&& o) { CVec_TxidZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxidZ)); return *this; }
- LDKCVec_TxidZ* operator &() { return &self; }
- LDKCVec_TxidZ* operator ->() { return &self; }
- const LDKCVec_TxidZ* operator &() const { return &self; }
- const LDKCVec_TxidZ* operator ->() const { return &self; }
-};
-class COption_AccessZ {
-private:
- LDKCOption_AccessZ self;
-public:
- COption_AccessZ(const COption_AccessZ&) = delete;
- COption_AccessZ(COption_AccessZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AccessZ)); }
- COption_AccessZ(LDKCOption_AccessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AccessZ)); }
- operator LDKCOption_AccessZ() && { LDKCOption_AccessZ res = self; memset(&self, 0, sizeof(LDKCOption_AccessZ)); return res; }
- ~COption_AccessZ() { COption_AccessZ_free(self); }
- COption_AccessZ& operator=(COption_AccessZ&& o) { COption_AccessZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AccessZ)); return *this; }
- LDKCOption_AccessZ* operator &() { return &self; }
- LDKCOption_AccessZ* operator ->() { return &self; }
- const LDKCOption_AccessZ* operator &() const { return &self; }
- const LDKCOption_AccessZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
-private:
- LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ self;
-public:
- CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(const CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&) = delete;
- CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
- CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); }
- operator LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() && { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return res; }
- ~CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ() { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); }
- CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ& operator=(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ&& o) { CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ)); return *this; }
- LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() { return &self; }
- LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
-private:
- LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ self;
-public:
- CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&) = delete;
- CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
- CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); }
- operator LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return res; }
- ~CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); }
- CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ)); return *this; }
- LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_PongDecodeErrorZ {
-private:
- LDKCResult_PongDecodeErrorZ self;
-public:
- CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
- CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
- CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
- operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
- ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
- CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
- LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
- LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_CVec_CVec_u8ZZNoneZ {
-private:
- LDKCResult_CVec_CVec_u8ZZNoneZ self;
-public:
- CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
- CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
- CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
- operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
- ~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
- CResult_CVec_CVec_u8ZZNoneZ& operator=(CResult_CVec_CVec_u8ZZNoneZ&& o) { CResult_CVec_CVec_u8ZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); return *this; }
- LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
- LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
- const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
- const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
-};
-class C2Tuple_SignatureSignatureZ {
-private:
- LDKC2Tuple_SignatureSignatureZ self;
-public:
- C2Tuple_SignatureSignatureZ(const C2Tuple_SignatureSignatureZ&) = delete;
- C2Tuple_SignatureSignatureZ(C2Tuple_SignatureSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); }
- C2Tuple_SignatureSignatureZ(LDKC2Tuple_SignatureSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); }
- operator LDKC2Tuple_SignatureSignatureZ() && { LDKC2Tuple_SignatureSignatureZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_SignatureSignatureZ)); return res; }
- ~C2Tuple_SignatureSignatureZ() { C2Tuple_SignatureSignatureZ_free(self); }
- C2Tuple_SignatureSignatureZ& operator=(C2Tuple_SignatureSignatureZ&& o) { C2Tuple_SignatureSignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_SignatureSignatureZ)); return *this; }
- LDKC2Tuple_SignatureSignatureZ* operator &() { return &self; }
- LDKC2Tuple_SignatureSignatureZ* operator ->() { return &self; }
- const LDKC2Tuple_SignatureSignatureZ* operator &() const { return &self; }
- const LDKC2Tuple_SignatureSignatureZ* operator ->() const { return &self; }
-};
-class C2Tuple_PaymentHashPaymentSecretZ {
-private:
- LDKC2Tuple_PaymentHashPaymentSecretZ self;
-public:
- C2Tuple_PaymentHashPaymentSecretZ(const C2Tuple_PaymentHashPaymentSecretZ&) = delete;
- C2Tuple_PaymentHashPaymentSecretZ(C2Tuple_PaymentHashPaymentSecretZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentSecretZ)); }
- C2Tuple_PaymentHashPaymentSecretZ(LDKC2Tuple_PaymentHashPaymentSecretZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ)); }
- operator LDKC2Tuple_PaymentHashPaymentSecretZ() && { LDKC2Tuple_PaymentHashPaymentSecretZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ)); return res; }
- ~C2Tuple_PaymentHashPaymentSecretZ() { C2Tuple_PaymentHashPaymentSecretZ_free(self); }
- C2Tuple_PaymentHashPaymentSecretZ& operator=(C2Tuple_PaymentHashPaymentSecretZ&& o) { C2Tuple_PaymentHashPaymentSecretZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentSecretZ)); return *this; }
- LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() { return &self; }
- LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() { return &self; }
- const LDKC2Tuple_PaymentHashPaymentSecretZ* operator &() const { return &self; }
- const LDKC2Tuple_PaymentHashPaymentSecretZ* operator ->() const { return &self; }
-};
-class C2Tuple_BlockHashChannelManagerZ {
-private:
- LDKC2Tuple_BlockHashChannelManagerZ self;
-public:
- C2Tuple_BlockHashChannelManagerZ(const C2Tuple_BlockHashChannelManagerZ&) = delete;
- C2Tuple_BlockHashChannelManagerZ(C2Tuple_BlockHashChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); }
- C2Tuple_BlockHashChannelManagerZ(LDKC2Tuple_BlockHashChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); }
- operator LDKC2Tuple_BlockHashChannelManagerZ() && { LDKC2Tuple_BlockHashChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlockHashChannelManagerZ)); return res; }
- ~C2Tuple_BlockHashChannelManagerZ() { C2Tuple_BlockHashChannelManagerZ_free(self); }
- C2Tuple_BlockHashChannelManagerZ& operator=(C2Tuple_BlockHashChannelManagerZ&& o) { C2Tuple_BlockHashChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlockHashChannelManagerZ)); return *this; }
- LDKC2Tuple_BlockHashChannelManagerZ* operator &() { return &self; }
- LDKC2Tuple_BlockHashChannelManagerZ* operator ->() { return &self; }
- const LDKC2Tuple_BlockHashChannelManagerZ* operator &() const { return &self; }
- const LDKC2Tuple_BlockHashChannelManagerZ* operator ->() const { return &self; }
-};
-class CResult_ChannelTransactionParametersDecodeErrorZ {
-private:
- LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
-public:
- CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
- CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
- CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
- operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
- ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
- CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
- LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+class CResult_BlindedPayInfoDecodeErrorZ {
+private:
+ LDKCResult_BlindedPayInfoDecodeErrorZ self;
+public:
+ CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
+ CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
+ CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
+ operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
+ ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
+ CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ThirtyTwoBytesAPIErrorZ {
+private:
+ LDKCResult_ThirtyTwoBytesAPIErrorZ self;
+public:
+ CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
+ CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
+ CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
+ operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
+ ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
+ CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
+ LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
+ LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
+ const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
+ const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
+};
+class COption_ChannelShutdownStateZ {
+private:
+ LDKCOption_ChannelShutdownStateZ self;
+public:
+ COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
+ COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
+ COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
+ operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
+ ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
+ COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
+ LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
+ LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
+ const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
+ const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
+};
+class CResult_Bolt12InvoiceBolt12SemanticErrorZ {
+private:
+ LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ self;
+public:
+ CResult_Bolt12InvoiceBolt12SemanticErrorZ(const CResult_Bolt12InvoiceBolt12SemanticErrorZ&) = delete;
+ CResult_Bolt12InvoiceBolt12SemanticErrorZ(CResult_Bolt12InvoiceBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceBolt12SemanticErrorZ)); }
+ CResult_Bolt12InvoiceBolt12SemanticErrorZ(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ)); }
+ operator LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ() && { LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ)); return res; }
+ ~CResult_Bolt12InvoiceBolt12SemanticErrorZ() { CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(self); }
+ CResult_Bolt12InvoiceBolt12SemanticErrorZ& operator=(CResult_Bolt12InvoiceBolt12SemanticErrorZ&& o) { CResult_Bolt12InvoiceBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt12InvoiceBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceRequestFieldsDecodeErrorZ {
+private:
+ LDKCResult_InvoiceRequestFieldsDecodeErrorZ self;
+public:
+ CResult_InvoiceRequestFieldsDecodeErrorZ(const CResult_InvoiceRequestFieldsDecodeErrorZ&) = delete;
+ CResult_InvoiceRequestFieldsDecodeErrorZ(CResult_InvoiceRequestFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestFieldsDecodeErrorZ)); }
+ CResult_InvoiceRequestFieldsDecodeErrorZ(LDKCResult_InvoiceRequestFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestFieldsDecodeErrorZ)); }
+ operator LDKCResult_InvoiceRequestFieldsDecodeErrorZ() && { LDKCResult_InvoiceRequestFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestFieldsDecodeErrorZ)); return res; }
+ ~CResult_InvoiceRequestFieldsDecodeErrorZ() { CResult_InvoiceRequestFieldsDecodeErrorZ_free(self); }
+ CResult_InvoiceRequestFieldsDecodeErrorZ& operator=(CResult_InvoiceRequestFieldsDecodeErrorZ&& o) { CResult_InvoiceRequestFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestFieldsDecodeErrorZ)); return *this; }
+ LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceRequestFieldsDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_AcceptChannelDecodeErrorZ {
private:
const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_SignatureZ {
-private:
- LDKCVec_SignatureZ self;
-public:
- CVec_SignatureZ(const CVec_SignatureZ&) = delete;
- CVec_SignatureZ(CVec_SignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SignatureZ)); }
- CVec_SignatureZ(LDKCVec_SignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SignatureZ)); }
- operator LDKCVec_SignatureZ() && { LDKCVec_SignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_SignatureZ)); return res; }
- ~CVec_SignatureZ() { CVec_SignatureZ_free(self); }
- CVec_SignatureZ& operator=(CVec_SignatureZ&& o) { CVec_SignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SignatureZ)); return *this; }
- LDKCVec_SignatureZ* operator &() { return &self; }
- LDKCVec_SignatureZ* operator ->() { return &self; }
- const LDKCVec_SignatureZ* operator &() const { return &self; }
- const LDKCVec_SignatureZ* operator ->() const { return &self; }
+class CResult_RefundDecodeErrorZ {
+private:
+ LDKCResult_RefundDecodeErrorZ self;
+public:
+ CResult_RefundDecodeErrorZ(const CResult_RefundDecodeErrorZ&) = delete;
+ CResult_RefundDecodeErrorZ(CResult_RefundDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundDecodeErrorZ)); }
+ CResult_RefundDecodeErrorZ(LDKCResult_RefundDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundDecodeErrorZ)); }
+ operator LDKCResult_RefundDecodeErrorZ() && { LDKCResult_RefundDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundDecodeErrorZ)); return res; }
+ ~CResult_RefundDecodeErrorZ() { CResult_RefundDecodeErrorZ_free(self); }
+ CResult_RefundDecodeErrorZ& operator=(CResult_RefundDecodeErrorZ&& o) { CResult_RefundDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundDecodeErrorZ)); return *this; }
+ LDKCResult_RefundDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RefundDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RefundDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RefundDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_HostnameDecodeErrorZ {
+private:
+ LDKCResult_HostnameDecodeErrorZ self;
+public:
+ CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
+ CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
+ CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
+ operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
+ ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
+ CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
+ LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_u64u16Z {
+private:
+ LDKC2Tuple_u64u16Z self;
+public:
+ C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
+ C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
+ C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
+ operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
+ ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
+ C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
+ LDKC2Tuple_u64u16Z* operator &() { return &self; }
+ LDKC2Tuple_u64u16Z* operator ->() { return &self; }
+ const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
+ const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
+};
+class COption_ThirtyTwoBytesZ {
+private:
+ LDKCOption_ThirtyTwoBytesZ self;
+public:
+ COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
+ COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
+ COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
+ operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
+ ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
+ COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
+ LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
+ LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
+ const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
+ const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
};
class CVec_u64Z {
private:
const LDKCVec_u64Z* operator &() const { return &self; }
const LDKCVec_u64Z* operator ->() const { return &self; }
};
-class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
-private:
- LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
-public:
- CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
- CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
- CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
- operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
- ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
- CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
- LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
-private:
- LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
-public:
- CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
- CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
- CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
- operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
- ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
- CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
- LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
- LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
-};
-class C2Tuple_PaymentHashPaymentIdZ {
-private:
- LDKC2Tuple_PaymentHashPaymentIdZ self;
-public:
- C2Tuple_PaymentHashPaymentIdZ(const C2Tuple_PaymentHashPaymentIdZ&) = delete;
- C2Tuple_PaymentHashPaymentIdZ(C2Tuple_PaymentHashPaymentIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); }
- C2Tuple_PaymentHashPaymentIdZ(LDKC2Tuple_PaymentHashPaymentIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); }
- operator LDKC2Tuple_PaymentHashPaymentIdZ() && { LDKC2Tuple_PaymentHashPaymentIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PaymentHashPaymentIdZ)); return res; }
- ~C2Tuple_PaymentHashPaymentIdZ() { C2Tuple_PaymentHashPaymentIdZ_free(self); }
- C2Tuple_PaymentHashPaymentIdZ& operator=(C2Tuple_PaymentHashPaymentIdZ&& o) { C2Tuple_PaymentHashPaymentIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PaymentHashPaymentIdZ)); return *this; }
- LDKC2Tuple_PaymentHashPaymentIdZ* operator &() { return &self; }
- LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() { return &self; }
- const LDKC2Tuple_PaymentHashPaymentIdZ* operator &() const { return &self; }
- const LDKC2Tuple_PaymentHashPaymentIdZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ {
-private:
- LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ self;
-public:
- CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(const CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&) = delete;
- CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
- CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); }
- operator LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() && { LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return res; }
- ~CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ() { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); }
- CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ& operator=(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ&& o) { CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ)); return *this; }
- LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() { return &self; }
- LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* operator ->() const { return &self; }
-};
-class CResult_NoneErrorZ {
-private:
- LDKCResult_NoneErrorZ self;
-public:
- CResult_NoneErrorZ(const CResult_NoneErrorZ&) = delete;
- CResult_NoneErrorZ(CResult_NoneErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneErrorZ)); }
- CResult_NoneErrorZ(LDKCResult_NoneErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneErrorZ)); }
- operator LDKCResult_NoneErrorZ() && { LDKCResult_NoneErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneErrorZ)); return res; }
- ~CResult_NoneErrorZ() { CResult_NoneErrorZ_free(self); }
- CResult_NoneErrorZ& operator=(CResult_NoneErrorZ&& o) { CResult_NoneErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneErrorZ)); return *this; }
- LDKCResult_NoneErrorZ* operator &() { return &self; }
- LDKCResult_NoneErrorZ* operator ->() { return &self; }
- const LDKCResult_NoneErrorZ* operator &() const { return &self; }
- const LDKCResult_NoneErrorZ* operator ->() const { return &self; }
-};
-class CResult_COption_HTLCDestinationZDecodeErrorZ {
-private:
- LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
-public:
- CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
- CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
- CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
- operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
- ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
- CResult_COption_HTLCDestinationZDecodeErrorZ& operator=(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); return *this; }
- LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_InFlightHtlcsDecodeErrorZ {
-private:
- LDKCResult_InFlightHtlcsDecodeErrorZ self;
-public:
- CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
- CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
- CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
- operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
- ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
- CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
- LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
- LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_StringErrorZ {
-private:
- LDKCResult_StringErrorZ self;
-public:
- CResult_StringErrorZ(const CResult_StringErrorZ&) = delete;
- CResult_StringErrorZ(CResult_StringErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StringErrorZ)); }
- CResult_StringErrorZ(LDKCResult_StringErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StringErrorZ)); }
- operator LDKCResult_StringErrorZ() && { LDKCResult_StringErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StringErrorZ)); return res; }
- ~CResult_StringErrorZ() { CResult_StringErrorZ_free(self); }
- CResult_StringErrorZ& operator=(CResult_StringErrorZ&& o) { CResult_StringErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StringErrorZ)); return *this; }
- LDKCResult_StringErrorZ* operator &() { return &self; }
- LDKCResult_StringErrorZ* operator ->() { return &self; }
- const LDKCResult_StringErrorZ* operator &() const { return &self; }
- const LDKCResult_StringErrorZ* operator ->() const { return &self; }
-};
-class CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ {
-private:
- LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ self;
-public:
- CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(const CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&) = delete;
- CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); }
- CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); }
- operator LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ() && { LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); return res; }
- ~CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ() { CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(self); }
- CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ& operator=(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ&& o) { CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ)); return *this; }
- LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() { return &self; }
- LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* operator ->() const { return &self; }
+class CResult_NoneBolt12SemanticErrorZ {
+private:
+ LDKCResult_NoneBolt12SemanticErrorZ self;
+public:
+ CResult_NoneBolt12SemanticErrorZ(const CResult_NoneBolt12SemanticErrorZ&) = delete;
+ CResult_NoneBolt12SemanticErrorZ(CResult_NoneBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); }
+ CResult_NoneBolt12SemanticErrorZ(LDKCResult_NoneBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); }
+ operator LDKCResult_NoneBolt12SemanticErrorZ() && { LDKCResult_NoneBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); return res; }
+ ~CResult_NoneBolt12SemanticErrorZ() { CResult_NoneBolt12SemanticErrorZ_free(self); }
+ CResult_NoneBolt12SemanticErrorZ& operator=(CResult_NoneBolt12SemanticErrorZ&& o) { CResult_NoneBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_NoneBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_NoneBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_NoneBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_NoneBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_UnknownPaymentContextDecodeErrorZ {
+private:
+ LDKCResult_UnknownPaymentContextDecodeErrorZ self;
+public:
+ CResult_UnknownPaymentContextDecodeErrorZ(const CResult_UnknownPaymentContextDecodeErrorZ&) = delete;
+ CResult_UnknownPaymentContextDecodeErrorZ(CResult_UnknownPaymentContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnknownPaymentContextDecodeErrorZ)); }
+ CResult_UnknownPaymentContextDecodeErrorZ(LDKCResult_UnknownPaymentContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnknownPaymentContextDecodeErrorZ)); }
+ operator LDKCResult_UnknownPaymentContextDecodeErrorZ() && { LDKCResult_UnknownPaymentContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnknownPaymentContextDecodeErrorZ)); return res; }
+ ~CResult_UnknownPaymentContextDecodeErrorZ() { CResult_UnknownPaymentContextDecodeErrorZ_free(self); }
+ CResult_UnknownPaymentContextDecodeErrorZ& operator=(CResult_UnknownPaymentContextDecodeErrorZ&& o) { CResult_UnknownPaymentContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnknownPaymentContextDecodeErrorZ)); return *this; }
+ LDKCResult_UnknownPaymentContextDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_UnknownPaymentContextDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_UnknownPaymentContextDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_UnknownPaymentContextDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_InboundHTLCStateDetailsZ {
+private:
+ LDKCOption_InboundHTLCStateDetailsZ self;
+public:
+ COption_InboundHTLCStateDetailsZ(const COption_InboundHTLCStateDetailsZ&) = delete;
+ COption_InboundHTLCStateDetailsZ(COption_InboundHTLCStateDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_InboundHTLCStateDetailsZ)); }
+ COption_InboundHTLCStateDetailsZ(LDKCOption_InboundHTLCStateDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_InboundHTLCStateDetailsZ)); }
+ operator LDKCOption_InboundHTLCStateDetailsZ() && { LDKCOption_InboundHTLCStateDetailsZ res = self; memset(&self, 0, sizeof(LDKCOption_InboundHTLCStateDetailsZ)); return res; }
+ ~COption_InboundHTLCStateDetailsZ() { COption_InboundHTLCStateDetailsZ_free(self); }
+ COption_InboundHTLCStateDetailsZ& operator=(COption_InboundHTLCStateDetailsZ&& o) { COption_InboundHTLCStateDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_InboundHTLCStateDetailsZ)); return *this; }
+ LDKCOption_InboundHTLCStateDetailsZ* operator &() { return &self; }
+ LDKCOption_InboundHTLCStateDetailsZ* operator ->() { return &self; }
+ const LDKCOption_InboundHTLCStateDetailsZ* operator &() const { return &self; }
+ const LDKCOption_InboundHTLCStateDetailsZ* operator ->() const { return &self; }
+};
+class CResult_OutputSweeperDecodeErrorZ {
+private:
+ LDKCResult_OutputSweeperDecodeErrorZ self;
+public:
+ CResult_OutputSweeperDecodeErrorZ(const CResult_OutputSweeperDecodeErrorZ&) = delete;
+ CResult_OutputSweeperDecodeErrorZ(CResult_OutputSweeperDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutputSweeperDecodeErrorZ)); }
+ CResult_OutputSweeperDecodeErrorZ(LDKCResult_OutputSweeperDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutputSweeperDecodeErrorZ)); }
+ operator LDKCResult_OutputSweeperDecodeErrorZ() && { LDKCResult_OutputSweeperDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutputSweeperDecodeErrorZ)); return res; }
+ ~CResult_OutputSweeperDecodeErrorZ() { CResult_OutputSweeperDecodeErrorZ_free(self); }
+ CResult_OutputSweeperDecodeErrorZ& operator=(CResult_OutputSweeperDecodeErrorZ&& o) { CResult_OutputSweeperDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutputSweeperDecodeErrorZ)); return *this; }
+ LDKCResult_OutputSweeperDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OutputSweeperDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OutputSweeperDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OutputSweeperDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_CVec_u8Zu64ZNoneZ {
+private:
+ LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ self;
+public:
+ CResult_C2Tuple_CVec_u8Zu64ZNoneZ(const CResult_C2Tuple_CVec_u8Zu64ZNoneZ&) = delete;
+ CResult_C2Tuple_CVec_u8Zu64ZNoneZ(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
+ CResult_C2Tuple_CVec_u8Zu64ZNoneZ(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
+ operator LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ() && { LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return res; }
+ ~CResult_C2Tuple_CVec_u8Zu64ZNoneZ() { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); }
+ CResult_C2Tuple_CVec_u8Zu64ZNoneZ& operator=(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return *this; }
+ LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() const { return &self; }
};
class COption_EventZ {
private:
const LDKCOption_EventZ* operator &() const { return &self; }
const LDKCOption_EventZ* operator ->() const { return &self; }
};
-class C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ {
-private:
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ self;
-public:
- C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(const C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&) = delete;
- C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
- C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); }
- operator LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() && { LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return res; }
- ~C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ() { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); }
- C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ& operator=(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ&& o) { C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ)); return *this; }
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() { return &self; }
- LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() { return &self; }
- const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator &() const { return &self; }
- const LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* operator ->() const { return &self; }
-};
class CResult_ChannelTypeFeaturesDecodeErrorZ {
private:
LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_SiPrefixParseErrorZ {
+class COption_CVec_SocketAddressZZ {
private:
- LDKCResult_SiPrefixParseErrorZ self;
+ LDKCOption_CVec_SocketAddressZZ self;
public:
- CResult_SiPrefixParseErrorZ(const CResult_SiPrefixParseErrorZ&) = delete;
- CResult_SiPrefixParseErrorZ(CResult_SiPrefixParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixParseErrorZ)); }
- CResult_SiPrefixParseErrorZ(LDKCResult_SiPrefixParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixParseErrorZ)); }
- operator LDKCResult_SiPrefixParseErrorZ() && { LDKCResult_SiPrefixParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixParseErrorZ)); return res; }
- ~CResult_SiPrefixParseErrorZ() { CResult_SiPrefixParseErrorZ_free(self); }
- CResult_SiPrefixParseErrorZ& operator=(CResult_SiPrefixParseErrorZ&& o) { CResult_SiPrefixParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixParseErrorZ)); return *this; }
- LDKCResult_SiPrefixParseErrorZ* operator &() { return &self; }
- LDKCResult_SiPrefixParseErrorZ* operator ->() { return &self; }
- const LDKCResult_SiPrefixParseErrorZ* operator &() const { return &self; }
- const LDKCResult_SiPrefixParseErrorZ* operator ->() const { return &self; }
+ COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
+ COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
+ COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
+ operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
+ ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
+ COption_CVec_SocketAddressZZ& operator=(COption_CVec_SocketAddressZZ&& o) { COption_CVec_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); return *this; }
+ LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
+ LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
+ const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
+ const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
};
class CVec_RouteHintZ {
private:
LDKCOption_u16Z* operator &() { return &self; }
LDKCOption_u16Z* operator ->() { return &self; }
const LDKCOption_u16Z* operator &() const { return &self; }
- const LDKCOption_u16Z* operator ->() const { return &self; }
-};
-class CResult_BlindedHopDecodeErrorZ {
-private:
- LDKCResult_BlindedHopDecodeErrorZ self;
-public:
- CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
- CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
- CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
- operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
- ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
- CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
- LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
- LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_CVec_RouteHopZZ {
-private:
- LDKCVec_CVec_RouteHopZZ self;
-public:
- CVec_CVec_RouteHopZZ(const CVec_CVec_RouteHopZZ&) = delete;
- CVec_CVec_RouteHopZZ(CVec_CVec_RouteHopZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); }
- CVec_CVec_RouteHopZZ(LDKCVec_CVec_RouteHopZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); }
- operator LDKCVec_CVec_RouteHopZZ() && { LDKCVec_CVec_RouteHopZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_RouteHopZZ)); return res; }
- ~CVec_CVec_RouteHopZZ() { CVec_CVec_RouteHopZZ_free(self); }
- CVec_CVec_RouteHopZZ& operator=(CVec_CVec_RouteHopZZ&& o) { CVec_CVec_RouteHopZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CVec_RouteHopZZ)); return *this; }
- LDKCVec_CVec_RouteHopZZ* operator &() { return &self; }
- LDKCVec_CVec_RouteHopZZ* operator ->() { return &self; }
- const LDKCVec_CVec_RouteHopZZ* operator &() const { return &self; }
- const LDKCVec_CVec_RouteHopZZ* operator ->() const { return &self; }
-};
-class CResult_TrustedCommitmentTransactionNoneZ {
-private:
- LDKCResult_TrustedCommitmentTransactionNoneZ self;
-public:
- CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
- CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
- CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
- operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
- ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
- CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
- LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
- LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
- const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
- const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
-};
-class CResult_FixedPenaltyScorerDecodeErrorZ {
-private:
- LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
-public:
- CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
- CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
- CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
- operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
- ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
- CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
- LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
- LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_NoneLightningErrorZ {
-private:
- LDKCResult_NoneLightningErrorZ self;
-public:
- CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
- CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
- CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
- operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
- ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
- CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
- LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
- LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
- const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
- const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
-};
-class CResult_NonePeerHandleErrorZ {
-private:
- LDKCResult_NonePeerHandleErrorZ self;
-public:
- CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
- CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
- CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
- operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
- ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
- CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
- LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
- LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
- const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
- const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
-};
-class CResult_COption_EventZDecodeErrorZ {
-private:
- LDKCResult_COption_EventZDecodeErrorZ self;
-public:
- CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
- CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
- CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
- operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
- ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
- CResult_COption_EventZDecodeErrorZ& operator=(CResult_COption_EventZDecodeErrorZ&& o) { CResult_COption_EventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); return *this; }
- LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_CVec_SignatureZNoneZ {
-private:
- LDKCResult_CVec_SignatureZNoneZ self;
-public:
- CResult_CVec_SignatureZNoneZ(const CResult_CVec_SignatureZNoneZ&) = delete;
- CResult_CVec_SignatureZNoneZ(CResult_CVec_SignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); }
- CResult_CVec_SignatureZNoneZ(LDKCResult_CVec_SignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); }
- operator LDKCResult_CVec_SignatureZNoneZ() && { LDKCResult_CVec_SignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_SignatureZNoneZ)); return res; }
- ~CResult_CVec_SignatureZNoneZ() { CResult_CVec_SignatureZNoneZ_free(self); }
- CResult_CVec_SignatureZNoneZ& operator=(CResult_CVec_SignatureZNoneZ&& o) { CResult_CVec_SignatureZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_SignatureZNoneZ)); return *this; }
- LDKCResult_CVec_SignatureZNoneZ* operator &() { return &self; }
- LDKCResult_CVec_SignatureZNoneZ* operator ->() { return &self; }
- const LDKCResult_CVec_SignatureZNoneZ* operator &() const { return &self; }
- const LDKCResult_CVec_SignatureZNoneZ* operator ->() const { return &self; }
-};
-class COption_CVec_NetAddressZZ {
-private:
- LDKCOption_CVec_NetAddressZZ self;
-public:
- COption_CVec_NetAddressZZ(const COption_CVec_NetAddressZZ&) = delete;
- COption_CVec_NetAddressZZ(COption_CVec_NetAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); }
- COption_CVec_NetAddressZZ(LDKCOption_CVec_NetAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); }
- operator LDKCOption_CVec_NetAddressZZ() && { LDKCOption_CVec_NetAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_NetAddressZZ)); return res; }
- ~COption_CVec_NetAddressZZ() { COption_CVec_NetAddressZZ_free(self); }
- COption_CVec_NetAddressZZ& operator=(COption_CVec_NetAddressZZ&& o) { COption_CVec_NetAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_NetAddressZZ)); return *this; }
- LDKCOption_CVec_NetAddressZZ* operator &() { return &self; }
- LDKCOption_CVec_NetAddressZZ* operator ->() { return &self; }
- const LDKCOption_CVec_NetAddressZZ* operator &() const { return &self; }
- const LDKCOption_CVec_NetAddressZZ* operator ->() const { return &self; }
-};
-class CResult__u832APIErrorZ {
-private:
- LDKCResult__u832APIErrorZ self;
-public:
- CResult__u832APIErrorZ(const CResult__u832APIErrorZ&) = delete;
- CResult__u832APIErrorZ(CResult__u832APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult__u832APIErrorZ)); }
- CResult__u832APIErrorZ(LDKCResult__u832APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult__u832APIErrorZ)); }
- operator LDKCResult__u832APIErrorZ() && { LDKCResult__u832APIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult__u832APIErrorZ)); return res; }
- ~CResult__u832APIErrorZ() { CResult__u832APIErrorZ_free(self); }
- CResult__u832APIErrorZ& operator=(CResult__u832APIErrorZ&& o) { CResult__u832APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult__u832APIErrorZ)); return *this; }
- LDKCResult__u832APIErrorZ* operator &() { return &self; }
- LDKCResult__u832APIErrorZ* operator ->() { return &self; }
- const LDKCResult__u832APIErrorZ* operator &() const { return &self; }
- const LDKCResult__u832APIErrorZ* operator ->() const { return &self; }
-};
-class CResult_PaymentIdPaymentErrorZ {
-private:
- LDKCResult_PaymentIdPaymentErrorZ self;
-public:
- CResult_PaymentIdPaymentErrorZ(const CResult_PaymentIdPaymentErrorZ&) = delete;
- CResult_PaymentIdPaymentErrorZ(CResult_PaymentIdPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); }
- CResult_PaymentIdPaymentErrorZ(LDKCResult_PaymentIdPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); }
- operator LDKCResult_PaymentIdPaymentErrorZ() && { LDKCResult_PaymentIdPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentIdPaymentErrorZ)); return res; }
- ~CResult_PaymentIdPaymentErrorZ() { CResult_PaymentIdPaymentErrorZ_free(self); }
- CResult_PaymentIdPaymentErrorZ& operator=(CResult_PaymentIdPaymentErrorZ&& o) { CResult_PaymentIdPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentIdPaymentErrorZ)); return *this; }
- LDKCResult_PaymentIdPaymentErrorZ* operator &() { return &self; }
- LDKCResult_PaymentIdPaymentErrorZ* operator ->() { return &self; }
- const LDKCResult_PaymentIdPaymentErrorZ* operator &() const { return &self; }
- const LDKCResult_PaymentIdPaymentErrorZ* operator ->() const { return &self; }
-};
-class CResult_DescriptionCreationErrorZ {
-private:
- LDKCResult_DescriptionCreationErrorZ self;
-public:
- CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
- CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
- CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
- operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
- ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
- CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
- LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
- LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
- const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
- const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
-};
-class CResult_RoutingFeesDecodeErrorZ {
-private:
- LDKCResult_RoutingFeesDecodeErrorZ self;
-public:
- CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
- CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
- CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
- operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
- ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
- CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
- LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
- LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_PayeePubKeyErrorZ {
-private:
- LDKCResult_PayeePubKeyErrorZ self;
-public:
- CResult_PayeePubKeyErrorZ(const CResult_PayeePubKeyErrorZ&) = delete;
- CResult_PayeePubKeyErrorZ(CResult_PayeePubKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); }
- CResult_PayeePubKeyErrorZ(LDKCResult_PayeePubKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); }
- operator LDKCResult_PayeePubKeyErrorZ() && { LDKCResult_PayeePubKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeyErrorZ)); return res; }
- ~CResult_PayeePubKeyErrorZ() { CResult_PayeePubKeyErrorZ_free(self); }
- CResult_PayeePubKeyErrorZ& operator=(CResult_PayeePubKeyErrorZ&& o) { CResult_PayeePubKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeyErrorZ)); return *this; }
- LDKCResult_PayeePubKeyErrorZ* operator &() { return &self; }
- LDKCResult_PayeePubKeyErrorZ* operator ->() { return &self; }
- const LDKCResult_PayeePubKeyErrorZ* operator &() const { return &self; }
- const LDKCResult_PayeePubKeyErrorZ* operator ->() const { return &self; }
-};
-class CResult_COption_MonitorEventZDecodeErrorZ {
-private:
- LDKCResult_COption_MonitorEventZDecodeErrorZ self;
-public:
- CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
- CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
- CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
- operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
- ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
- CResult_COption_MonitorEventZDecodeErrorZ& operator=(CResult_COption_MonitorEventZDecodeErrorZ&& o) { CResult_COption_MonitorEventZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); return *this; }
- LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
+ const LDKCOption_u16Z* operator ->() const { return &self; }
};
-class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
-private:
- LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
-public:
- C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
- C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
- C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
- operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
- ~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
- C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ& operator=(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return *this; }
- LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
- LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
- const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
- const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
+class COption_PaymentFailureReasonZ {
+private:
+ LDKCOption_PaymentFailureReasonZ self;
+public:
+ COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
+ COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
+ COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
+ operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
+ ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
+ COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
+ LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
+ LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
+ const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
+ const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
+};
+class CResult_Bolt12RefundContextDecodeErrorZ {
+private:
+ LDKCResult_Bolt12RefundContextDecodeErrorZ self;
+public:
+ CResult_Bolt12RefundContextDecodeErrorZ(const CResult_Bolt12RefundContextDecodeErrorZ&) = delete;
+ CResult_Bolt12RefundContextDecodeErrorZ(CResult_Bolt12RefundContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12RefundContextDecodeErrorZ)); }
+ CResult_Bolt12RefundContextDecodeErrorZ(LDKCResult_Bolt12RefundContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12RefundContextDecodeErrorZ)); }
+ operator LDKCResult_Bolt12RefundContextDecodeErrorZ() && { LDKCResult_Bolt12RefundContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12RefundContextDecodeErrorZ)); return res; }
+ ~CResult_Bolt12RefundContextDecodeErrorZ() { CResult_Bolt12RefundContextDecodeErrorZ_free(self); }
+ CResult_Bolt12RefundContextDecodeErrorZ& operator=(CResult_Bolt12RefundContextDecodeErrorZ&& o) { CResult_Bolt12RefundContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12RefundContextDecodeErrorZ)); return *this; }
+ LDKCResult_Bolt12RefundContextDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt12RefundContextDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt12RefundContextDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt12RefundContextDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_ECDSASignatureNoneZ {
+private:
+ LDKCResult_ECDSASignatureNoneZ self;
+public:
+ CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
+ CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
+ CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
+ operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
+ ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
+ CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
+ LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
+ LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
+ const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
+ const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
+};
+class C2Tuple_ChannelIdPublicKeyZ {
+private:
+ LDKC2Tuple_ChannelIdPublicKeyZ self;
+public:
+ C2Tuple_ChannelIdPublicKeyZ(const C2Tuple_ChannelIdPublicKeyZ&) = delete;
+ C2Tuple_ChannelIdPublicKeyZ(C2Tuple_ChannelIdPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ChannelIdPublicKeyZ)); }
+ C2Tuple_ChannelIdPublicKeyZ(LDKC2Tuple_ChannelIdPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ChannelIdPublicKeyZ)); }
+ operator LDKC2Tuple_ChannelIdPublicKeyZ() && { LDKC2Tuple_ChannelIdPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ChannelIdPublicKeyZ)); return res; }
+ ~C2Tuple_ChannelIdPublicKeyZ() { C2Tuple_ChannelIdPublicKeyZ_free(self); }
+ C2Tuple_ChannelIdPublicKeyZ& operator=(C2Tuple_ChannelIdPublicKeyZ&& o) { C2Tuple_ChannelIdPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ChannelIdPublicKeyZ)); return *this; }
+ LDKC2Tuple_ChannelIdPublicKeyZ* operator &() { return &self; }
+ LDKC2Tuple_ChannelIdPublicKeyZ* operator ->() { return &self; }
+ const LDKC2Tuple_ChannelIdPublicKeyZ* operator &() const { return &self; }
+ const LDKC2Tuple_ChannelIdPublicKeyZ* operator ->() const { return &self; }
+};
+class C2Tuple_OffersMessageResponseInstructionZ {
+private:
+ LDKC2Tuple_OffersMessageResponseInstructionZ self;
+public:
+ C2Tuple_OffersMessageResponseInstructionZ(const C2Tuple_OffersMessageResponseInstructionZ&) = delete;
+ C2Tuple_OffersMessageResponseInstructionZ(C2Tuple_OffersMessageResponseInstructionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OffersMessageResponseInstructionZ)); }
+ C2Tuple_OffersMessageResponseInstructionZ(LDKC2Tuple_OffersMessageResponseInstructionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OffersMessageResponseInstructionZ)); }
+ operator LDKC2Tuple_OffersMessageResponseInstructionZ() && { LDKC2Tuple_OffersMessageResponseInstructionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OffersMessageResponseInstructionZ)); return res; }
+ ~C2Tuple_OffersMessageResponseInstructionZ() { C2Tuple_OffersMessageResponseInstructionZ_free(self); }
+ C2Tuple_OffersMessageResponseInstructionZ& operator=(C2Tuple_OffersMessageResponseInstructionZ&& o) { C2Tuple_OffersMessageResponseInstructionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OffersMessageResponseInstructionZ)); return *this; }
+ LDKC2Tuple_OffersMessageResponseInstructionZ* operator &() { return &self; }
+ LDKC2Tuple_OffersMessageResponseInstructionZ* operator ->() { return &self; }
+ const LDKC2Tuple_OffersMessageResponseInstructionZ* operator &() const { return &self; }
+ const LDKC2Tuple_OffersMessageResponseInstructionZ* operator ->() const { return &self; }
+};
+class CResult_EcdsaChannelSignerDecodeErrorZ {
+private:
+ LDKCResult_EcdsaChannelSignerDecodeErrorZ self;
+public:
+ CResult_EcdsaChannelSignerDecodeErrorZ(const CResult_EcdsaChannelSignerDecodeErrorZ&) = delete;
+ CResult_EcdsaChannelSignerDecodeErrorZ(CResult_EcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_EcdsaChannelSignerDecodeErrorZ)); }
+ CResult_EcdsaChannelSignerDecodeErrorZ(LDKCResult_EcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_EcdsaChannelSignerDecodeErrorZ)); }
+ operator LDKCResult_EcdsaChannelSignerDecodeErrorZ() && { LDKCResult_EcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_EcdsaChannelSignerDecodeErrorZ)); return res; }
+ ~CResult_EcdsaChannelSignerDecodeErrorZ() { CResult_EcdsaChannelSignerDecodeErrorZ_free(self); }
+ CResult_EcdsaChannelSignerDecodeErrorZ& operator=(CResult_EcdsaChannelSignerDecodeErrorZ&& o) { CResult_EcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_EcdsaChannelSignerDecodeErrorZ)); return *this; }
+ LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_EcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_BlindedTailDecodeErrorZ {
+private:
+ LDKCResult_BlindedTailDecodeErrorZ self;
+public:
+ CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
+ CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
+ CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
+ operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
+ ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
+ CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
+};
+class CVec_WitnessZ {
+private:
+ LDKCVec_WitnessZ self;
+public:
+ CVec_WitnessZ(const CVec_WitnessZ&) = delete;
+ CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
+ CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
+ operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
+ ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
+ CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
+ LDKCVec_WitnessZ* operator &() { return &self; }
+ LDKCVec_WitnessZ* operator ->() { return &self; }
+ const LDKCVec_WitnessZ* operator &() const { return &self; }
+ const LDKCVec_WitnessZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_u64u16ZZ {
+private:
+ LDKCOption_C2Tuple_u64u16ZZ self;
+public:
+ COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
+ COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
+ COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
+ operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
+ ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
+ COption_C2Tuple_u64u16ZZ& operator=(COption_C2Tuple_u64u16ZZ&& o) { COption_C2Tuple_u64u16ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); return *this; }
+ LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
+ LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
+ const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
+ const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
+};
+class CResult_SocketAddressSocketAddressParseErrorZ {
+private:
+ LDKCResult_SocketAddressSocketAddressParseErrorZ self;
+public:
+ CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
+ CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
+ CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
+ operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
+ ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
+ CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
+ LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
+ LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
+ const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
+ const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
+};
+class CResult_COption_PaymentFailureReasonZDecodeErrorZ {
+private:
+ LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ self;
+public:
+ CResult_COption_PaymentFailureReasonZDecodeErrorZ(const CResult_COption_PaymentFailureReasonZDecodeErrorZ&) = delete;
+ CResult_COption_PaymentFailureReasonZDecodeErrorZ(CResult_COption_PaymentFailureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PaymentFailureReasonZDecodeErrorZ)); }
+ CResult_COption_PaymentFailureReasonZDecodeErrorZ(LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ)); }
+ operator LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ() && { LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ)); return res; }
+ ~CResult_COption_PaymentFailureReasonZDecodeErrorZ() { CResult_COption_PaymentFailureReasonZDecodeErrorZ_free(self); }
+ CResult_COption_PaymentFailureReasonZDecodeErrorZ& operator=(CResult_COption_PaymentFailureReasonZDecodeErrorZ&& o) { CResult_COption_PaymentFailureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_PaymentFailureReasonZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_PaymentFailureReasonZDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
+private:
+ LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
+public:
+ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
+ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
+ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
+ operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
+ ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
+ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return *this; }
+ LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
+ LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
+};
+class CResult_ChannelDerivationParametersDecodeErrorZ {
+private:
+ LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
+public:
+ CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
+ CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
+ CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
+ operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
+ ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
+ CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
+private:
+ LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
+public:
+ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
+ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
+ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
+ operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
+ ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
+ CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
+ LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
+ LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
+ const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
+ const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
+};
+class CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ {
+private:
+ LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ self;
+public:
+ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(const CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&) = delete;
+ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); }
+ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); }
+ operator LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ() && { LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); return res; }
+ ~CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ() { CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(self); }
+ CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ& operator=(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ&& o) { CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedInvoiceRequestBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_UnsignedInvoiceRequestBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_OnionMessagePathNoneZ {
+private:
+ LDKCResult_OnionMessagePathNoneZ self;
+public:
+ CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
+ CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
+ CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
+ operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
+ ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
+ CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
+ LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
+ LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
+ const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
+ const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
+};
+class C2Tuple_u32CVec_u8ZZ {
+private:
+ LDKC2Tuple_u32CVec_u8ZZ self;
+public:
+ C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
+ C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
+ C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
+ operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
+ ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
+ C2Tuple_u32CVec_u8ZZ& operator=(C2Tuple_u32CVec_u8ZZ&& o) { C2Tuple_u32CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); return *this; }
+ LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
+ LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
+ const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
+ const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
};
class CVec_C2Tuple_PublicKeyTypeZZ {
private:
const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
};
-class CResult_InvoiceSemanticErrorZ {
+class CResult_OutboundHTLCDetailsDecodeErrorZ {
+private:
+ LDKCResult_OutboundHTLCDetailsDecodeErrorZ self;
+public:
+ CResult_OutboundHTLCDetailsDecodeErrorZ(const CResult_OutboundHTLCDetailsDecodeErrorZ&) = delete;
+ CResult_OutboundHTLCDetailsDecodeErrorZ(CResult_OutboundHTLCDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutboundHTLCDetailsDecodeErrorZ)); }
+ CResult_OutboundHTLCDetailsDecodeErrorZ(LDKCResult_OutboundHTLCDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutboundHTLCDetailsDecodeErrorZ)); }
+ operator LDKCResult_OutboundHTLCDetailsDecodeErrorZ() && { LDKCResult_OutboundHTLCDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutboundHTLCDetailsDecodeErrorZ)); return res; }
+ ~CResult_OutboundHTLCDetailsDecodeErrorZ() { CResult_OutboundHTLCDetailsDecodeErrorZ_free(self); }
+ CResult_OutboundHTLCDetailsDecodeErrorZ& operator=(CResult_OutboundHTLCDetailsDecodeErrorZ&& o) { CResult_OutboundHTLCDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutboundHTLCDetailsDecodeErrorZ)); return *this; }
+ LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OutboundHTLCDetailsDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_RefundBolt12ParseErrorZ {
private:
- LDKCResult_InvoiceSemanticErrorZ self;
+ LDKCResult_RefundBolt12ParseErrorZ self;
public:
- CResult_InvoiceSemanticErrorZ(const CResult_InvoiceSemanticErrorZ&) = delete;
- CResult_InvoiceSemanticErrorZ(CResult_InvoiceSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); }
- CResult_InvoiceSemanticErrorZ(LDKCResult_InvoiceSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); }
- operator LDKCResult_InvoiceSemanticErrorZ() && { LDKCResult_InvoiceSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceSemanticErrorZ)); return res; }
- ~CResult_InvoiceSemanticErrorZ() { CResult_InvoiceSemanticErrorZ_free(self); }
- CResult_InvoiceSemanticErrorZ& operator=(CResult_InvoiceSemanticErrorZ&& o) { CResult_InvoiceSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceSemanticErrorZ)); return *this; }
- LDKCResult_InvoiceSemanticErrorZ* operator &() { return &self; }
- LDKCResult_InvoiceSemanticErrorZ* operator ->() { return &self; }
- const LDKCResult_InvoiceSemanticErrorZ* operator &() const { return &self; }
- const LDKCResult_InvoiceSemanticErrorZ* operator ->() const { return &self; }
+ CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
+ CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
+ CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
+ operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
+ ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
+ CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
+ LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
+ LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
+ const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
+ const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
};
class CResult_u32GraphSyncErrorZ {
private:
const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
};
-class CResult_UpdateAddHTLCDecodeErrorZ {
-private:
- LDKCResult_UpdateAddHTLCDecodeErrorZ self;
-public:
- CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
- CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
- CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
- operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
- ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
- CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
- LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
-private:
- LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
-public:
- CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
- CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
- CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
- operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
- ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
- CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
- LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
- LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
+class CVec_C2Tuple_u64CVec_u8ZZZ {
+private:
+ LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
+public:
+ CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
+ CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
+ CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
+ operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
+ ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
+ CVec_C2Tuple_u64CVec_u8ZZZ& operator=(CVec_C2Tuple_u64CVec_u8ZZZ&& o) { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); return *this; }
+ LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
+};
+class CResult_OffersMessageDecodeErrorZ {
+private:
+ LDKCResult_OffersMessageDecodeErrorZ self;
+public:
+ CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
+ CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
+ CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
+ operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
+ ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
+ CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
+ LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_PaymentConstraintsDecodeErrorZ {
+private:
+ LDKCResult_PaymentConstraintsDecodeErrorZ self;
+public:
+ CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
+ CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
+ CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
+ operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
+ ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
+ CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
+ LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_NoneAPIErrorZ {
private:
const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
};
-class CVec_NetAddressZ {
-private:
- LDKCVec_NetAddressZ self;
-public:
- CVec_NetAddressZ(const CVec_NetAddressZ&) = delete;
- CVec_NetAddressZ(CVec_NetAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NetAddressZ)); }
- CVec_NetAddressZ(LDKCVec_NetAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NetAddressZ)); }
- operator LDKCVec_NetAddressZ() && { LDKCVec_NetAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_NetAddressZ)); return res; }
- ~CVec_NetAddressZ() { CVec_NetAddressZ_free(self); }
- CVec_NetAddressZ& operator=(CVec_NetAddressZ&& o) { CVec_NetAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NetAddressZ)); return *this; }
- LDKCVec_NetAddressZ* operator &() { return &self; }
- LDKCVec_NetAddressZ* operator ->() { return &self; }
- const LDKCVec_NetAddressZ* operator &() const { return &self; }
- const LDKCVec_NetAddressZ* operator ->() const { return &self; }
-};
-class CResult_ChannelDetailsDecodeErrorZ {
-private:
- LDKCResult_ChannelDetailsDecodeErrorZ self;
-public:
- CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
- CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
- CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
- operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
- ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
- CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
- LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
+class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
+private:
+ LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
+public:
+ CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
+ CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
+ CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
+ operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
+ ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
+ CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
+ LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_f64Z {
+private:
+ LDKCOption_f64Z self;
+public:
+ COption_f64Z(const COption_f64Z&) = delete;
+ COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
+ COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
+ operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
+ ~COption_f64Z() { COption_f64Z_free(self); }
+ COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
+ LDKCOption_f64Z* operator &() { return &self; }
+ LDKCOption_f64Z* operator ->() { return &self; }
+ const LDKCOption_f64Z* operator &() const { return &self; }
+ const LDKCOption_f64Z* operator ->() const { return &self; }
+};
+class CResult_TxRemoveInputDecodeErrorZ {
+private:
+ LDKCResult_TxRemoveInputDecodeErrorZ self;
+public:
+ CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
+ CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
+ CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
+ operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
+ ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
+ CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
+ LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
};
class CVec_PublicKeyZ {
private:
const LDKCVec_PublicKeyZ* operator &() const { return &self; }
const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
};
+class C2Tuple_CVec_u8Zu64Z {
+private:
+ LDKC2Tuple_CVec_u8Zu64Z self;
+public:
+ C2Tuple_CVec_u8Zu64Z(const C2Tuple_CVec_u8Zu64Z&) = delete;
+ C2Tuple_CVec_u8Zu64Z(C2Tuple_CVec_u8Zu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); }
+ C2Tuple_CVec_u8Zu64Z(LDKC2Tuple_CVec_u8Zu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); }
+ operator LDKC2Tuple_CVec_u8Zu64Z() && { LDKC2Tuple_CVec_u8Zu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); return res; }
+ ~C2Tuple_CVec_u8Zu64Z() { C2Tuple_CVec_u8Zu64Z_free(self); }
+ C2Tuple_CVec_u8Zu64Z& operator=(C2Tuple_CVec_u8Zu64Z&& o) { C2Tuple_CVec_u8Zu64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); return *this; }
+ LDKC2Tuple_CVec_u8Zu64Z* operator &() { return &self; }
+ LDKC2Tuple_CVec_u8Zu64Z* operator ->() { return &self; }
+ const LDKC2Tuple_CVec_u8Zu64Z* operator &() const { return &self; }
+ const LDKC2Tuple_CVec_u8Zu64Z* operator ->() const { return &self; }
+};
class CVec_C2Tuple_usizeTransactionZZ {
private:
LDKCVec_C2Tuple_usizeTransactionZZ self;
const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
};
-class CResult_QueryShortChannelIdsDecodeErrorZ {
-private:
- LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
-public:
- CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
- CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
- CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
- operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
- ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
- CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
- LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
- LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_PhantomRouteHintsZ {
+class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
private:
- LDKCVec_PhantomRouteHintsZ self;
+ LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
public:
- CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
- CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
- CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
- operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
- ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
- CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
- LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
- LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
- const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
- const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
+ CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
+ CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
+ CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
+ operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
+ ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
+ CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return *this; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
};
-class COption_MonitorEventZ {
+class CResult_Bolt12InvoiceDecodeErrorZ {
private:
- LDKCOption_MonitorEventZ self;
+ LDKCResult_Bolt12InvoiceDecodeErrorZ self;
public:
- COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
- COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
- COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
- operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
- ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
- COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
- LDKCOption_MonitorEventZ* operator &() { return &self; }
- LDKCOption_MonitorEventZ* operator ->() { return &self; }
- const LDKCOption_MonitorEventZ* operator &() const { return &self; }
- const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
+ CResult_Bolt12InvoiceDecodeErrorZ(const CResult_Bolt12InvoiceDecodeErrorZ&) = delete;
+ CResult_Bolt12InvoiceDecodeErrorZ(CResult_Bolt12InvoiceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceDecodeErrorZ)); }
+ CResult_Bolt12InvoiceDecodeErrorZ(LDKCResult_Bolt12InvoiceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceDecodeErrorZ)); }
+ operator LDKCResult_Bolt12InvoiceDecodeErrorZ() && { LDKCResult_Bolt12InvoiceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceDecodeErrorZ)); return res; }
+ ~CResult_Bolt12InvoiceDecodeErrorZ() { CResult_Bolt12InvoiceDecodeErrorZ_free(self); }
+ CResult_Bolt12InvoiceDecodeErrorZ& operator=(CResult_Bolt12InvoiceDecodeErrorZ&& o) { CResult_Bolt12InvoiceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceDecodeErrorZ)); return *this; }
+ LDKCResult_Bolt12InvoiceDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_Bolt12InvoiceDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_Bolt12InvoiceDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_Bolt12InvoiceDecodeErrorZ* operator ->() const { return &self; }
};
class C2Tuple_u64u64Z {
private:
const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
};
-class COption_TypeZ {
-private:
- LDKCOption_TypeZ self;
-public:
- COption_TypeZ(const COption_TypeZ&) = delete;
- COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
- COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
- operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
- ~COption_TypeZ() { COption_TypeZ_free(self); }
- COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
- LDKCOption_TypeZ* operator &() { return &self; }
- LDKCOption_TypeZ* operator ->() { return &self; }
- const LDKCOption_TypeZ* operator &() const { return &self; }
- const LDKCOption_TypeZ* operator ->() const { return &self; }
-};
-class CResult_COption_TypeZDecodeErrorZ {
-private:
- LDKCResult_COption_TypeZDecodeErrorZ self;
-public:
- CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
- CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
- CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
- operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
- ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
- CResult_COption_TypeZDecodeErrorZ& operator=(CResult_COption_TypeZDecodeErrorZ&& o) { CResult_COption_TypeZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); return *this; }
- LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
+class COption_NodeAnnouncementInfoZ {
+private:
+ LDKCOption_NodeAnnouncementInfoZ self;
+public:
+ COption_NodeAnnouncementInfoZ(const COption_NodeAnnouncementInfoZ&) = delete;
+ COption_NodeAnnouncementInfoZ(COption_NodeAnnouncementInfoZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NodeAnnouncementInfoZ)); }
+ COption_NodeAnnouncementInfoZ(LDKCOption_NodeAnnouncementInfoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NodeAnnouncementInfoZ)); }
+ operator LDKCOption_NodeAnnouncementInfoZ() && { LDKCOption_NodeAnnouncementInfoZ res = self; memset(&self, 0, sizeof(LDKCOption_NodeAnnouncementInfoZ)); return res; }
+ ~COption_NodeAnnouncementInfoZ() { COption_NodeAnnouncementInfoZ_free(self); }
+ COption_NodeAnnouncementInfoZ& operator=(COption_NodeAnnouncementInfoZ&& o) { COption_NodeAnnouncementInfoZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NodeAnnouncementInfoZ)); return *this; }
+ LDKCOption_NodeAnnouncementInfoZ* operator &() { return &self; }
+ LDKCOption_NodeAnnouncementInfoZ* operator ->() { return &self; }
+ const LDKCOption_NodeAnnouncementInfoZ* operator &() const { return &self; }
+ const LDKCOption_NodeAnnouncementInfoZ* operator ->() const { return &self; }
+};
+class CResult_PendingHTLCRoutingDecodeErrorZ {
+private:
+ LDKCResult_PendingHTLCRoutingDecodeErrorZ self;
+public:
+ CResult_PendingHTLCRoutingDecodeErrorZ(const CResult_PendingHTLCRoutingDecodeErrorZ&) = delete;
+ CResult_PendingHTLCRoutingDecodeErrorZ(CResult_PendingHTLCRoutingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); }
+ CResult_PendingHTLCRoutingDecodeErrorZ(LDKCResult_PendingHTLCRoutingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); }
+ operator LDKCResult_PendingHTLCRoutingDecodeErrorZ() && { LDKCResult_PendingHTLCRoutingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); return res; }
+ ~CResult_PendingHTLCRoutingDecodeErrorZ() { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); }
+ CResult_PendingHTLCRoutingDecodeErrorZ& operator=(CResult_PendingHTLCRoutingDecodeErrorZ&& o) { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); return *this; }
+ LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_OnionMessageContentsResponseInstructionZZ {
+private:
+ LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ self;
+public:
+ COption_C2Tuple_OnionMessageContentsResponseInstructionZZ(const COption_C2Tuple_OnionMessageContentsResponseInstructionZZ&) = delete;
+ COption_C2Tuple_OnionMessageContentsResponseInstructionZZ(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); }
+ COption_C2Tuple_OnionMessageContentsResponseInstructionZZ(LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); }
+ operator LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ() && { LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); return res; }
+ ~COption_C2Tuple_OnionMessageContentsResponseInstructionZZ() { COption_C2Tuple_OnionMessageContentsResponseInstructionZZ_free(self); }
+ COption_C2Tuple_OnionMessageContentsResponseInstructionZZ& operator=(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ&& o) { COption_C2Tuple_OnionMessageContentsResponseInstructionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_OnionMessageContentsResponseInstructionZZ)); return *this; }
+ LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator &() { return &self; }
+ LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator ->() { return &self; }
+ const LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator &() const { return &self; }
+ const LDKCOption_C2Tuple_OnionMessageContentsResponseInstructionZZ* operator ->() const { return &self; }
+};
+class CResult_RecipientOnionFieldsDecodeErrorZ {
+private:
+ LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
+public:
+ CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
+ CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
+ CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
+ operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
+ ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
+ CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
+ LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
};
class C2Tuple_u32TxOutZ {
private:
const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
};
-class CResult_UpdateFailHTLCDecodeErrorZ {
+class CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ {
private:
- LDKCResult_UpdateFailHTLCDecodeErrorZ self;
+ LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ self;
public:
- CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
- CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
- CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
- operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
- ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
- CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
- LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
+ CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(const CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&) = delete;
+ CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); }
+ CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); }
+ operator LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); return res; }
+ ~CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ() { CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(self); }
+ CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceRequestWithExplicitPayerIdBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ {
+private:
+ LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ self;
+public:
+ CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(const CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&) = delete;
+ CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+ CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); }
+ operator LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ() && { LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); return res; }
+ ~CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ() { CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); }
+ CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ& operator=(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ&& o) { CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ)); return *this; }
+ LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() { return &self; }
+ LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() { return &self; }
+ const LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator &() const { return &self; }
+ const LDKCResult_InvoiceWithDerivedSigningPubkeyBuilderBolt12SemanticErrorZ* operator ->() const { return &self; }
+};
+class CResult_ChannelDetailsDecodeErrorZ {
+private:
+ LDKCResult_ChannelDetailsDecodeErrorZ self;
+public:
+ CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
+ CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
+ CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
+ operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
+ ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
+ CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
+ LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_InvoiceParseOrSemanticErrorZ {
+class CVec_UtxoZ {
private:
- LDKCResult_InvoiceParseOrSemanticErrorZ self;
+ LDKCVec_UtxoZ self;
public:
- CResult_InvoiceParseOrSemanticErrorZ(const CResult_InvoiceParseOrSemanticErrorZ&) = delete;
- CResult_InvoiceParseOrSemanticErrorZ(CResult_InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceParseOrSemanticErrorZ)); }
- CResult_InvoiceParseOrSemanticErrorZ(LDKCResult_InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ)); }
- operator LDKCResult_InvoiceParseOrSemanticErrorZ() && { LDKCResult_InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ)); return res; }
- ~CResult_InvoiceParseOrSemanticErrorZ() { CResult_InvoiceParseOrSemanticErrorZ_free(self); }
- CResult_InvoiceParseOrSemanticErrorZ& operator=(CResult_InvoiceParseOrSemanticErrorZ&& o) { CResult_InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceParseOrSemanticErrorZ)); return *this; }
- LDKCResult_InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
- LDKCResult_InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
- const LDKCResult_InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
- const LDKCResult_InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
+ CVec_UtxoZ(const CVec_UtxoZ&) = delete;
+ CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
+ CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
+ operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
+ ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
+ CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
+ LDKCVec_UtxoZ* operator &() { return &self; }
+ LDKCVec_UtxoZ* operator ->() { return &self; }
+ const LDKCVec_UtxoZ* operator &() const { return &self; }
+ const LDKCVec_UtxoZ* operator ->() const { return &self; }
};
-class CResult_PaymentSecretNoneZ {
+class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
private:
- LDKCResult_PaymentSecretNoneZ self;
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
public:
- CResult_PaymentSecretNoneZ(const CResult_PaymentSecretNoneZ&) = delete;
- CResult_PaymentSecretNoneZ(CResult_PaymentSecretNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretNoneZ)); }
- CResult_PaymentSecretNoneZ(LDKCResult_PaymentSecretNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretNoneZ)); }
- operator LDKCResult_PaymentSecretNoneZ() && { LDKCResult_PaymentSecretNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretNoneZ)); return res; }
- ~CResult_PaymentSecretNoneZ() { CResult_PaymentSecretNoneZ_free(self); }
- CResult_PaymentSecretNoneZ& operator=(CResult_PaymentSecretNoneZ&& o) { CResult_PaymentSecretNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretNoneZ)); return *this; }
- LDKCResult_PaymentSecretNoneZ* operator &() { return &self; }
- LDKCResult_PaymentSecretNoneZ* operator ->() { return &self; }
- const LDKCResult_PaymentSecretNoneZ* operator &() const { return &self; }
- const LDKCResult_PaymentSecretNoneZ* operator ->() const { return &self; }
+ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
+ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
+ operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
+ ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
+ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_ChannelConfigDecodeErrorZ {
private:
const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
};
-class CResult_SpendableOutputDescriptorDecodeErrorZ {
-private:
- LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
-public:
- CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
- CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
- CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
- operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
- ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
- CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
- LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
- LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_RevokeAndACKDecodeErrorZ {
-private:
- LDKCResult_RevokeAndACKDecodeErrorZ self;
-public:
- CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
- CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
- CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
- operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
- ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
- CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
- LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
- LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_UnsignedChannelUpdateDecodeErrorZ {
+class COption_i64Z {
private:
- LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
+ LDKCOption_i64Z self;
public:
- CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
- CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
- CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
- operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
- ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
- CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
- LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
+ COption_i64Z(const COption_i64Z&) = delete;
+ COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
+ COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
+ operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
+ ~COption_i64Z() { COption_i64Z_free(self); }
+ COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
+ LDKCOption_i64Z* operator &() { return &self; }
+ LDKCOption_i64Z* operator ->() { return &self; }
+ const LDKCOption_i64Z* operator &() const { return &self; }
+ const LDKCOption_i64Z* operator ->() const { return &self; }
};
-class CResult_ShutdownDecodeErrorZ {
+class CResult_PaymentContextDecodeErrorZ {
private:
- LDKCResult_ShutdownDecodeErrorZ self;
+ LDKCResult_PaymentContextDecodeErrorZ self;
public:
- CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
- CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
- CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
- operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
- ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
- CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
- LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
+ CResult_PaymentContextDecodeErrorZ(const CResult_PaymentContextDecodeErrorZ&) = delete;
+ CResult_PaymentContextDecodeErrorZ(CResult_PaymentContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentContextDecodeErrorZ)); }
+ CResult_PaymentContextDecodeErrorZ(LDKCResult_PaymentContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentContextDecodeErrorZ)); }
+ operator LDKCResult_PaymentContextDecodeErrorZ() && { LDKCResult_PaymentContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentContextDecodeErrorZ)); return res; }
+ ~CResult_PaymentContextDecodeErrorZ() { CResult_PaymentContextDecodeErrorZ_free(self); }
+ CResult_PaymentContextDecodeErrorZ& operator=(CResult_PaymentContextDecodeErrorZ&& o) { CResult_PaymentContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentContextDecodeErrorZ)); return *this; }
+ LDKCResult_PaymentContextDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_PaymentContextDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_PaymentContextDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_PaymentContextDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_EventZ {
+class CVec_PhantomRouteHintsZ {
private:
- LDKCVec_EventZ self;
+ LDKCVec_PhantomRouteHintsZ self;
public:
- CVec_EventZ(const CVec_EventZ&) = delete;
- CVec_EventZ(CVec_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_EventZ)); }
- CVec_EventZ(LDKCVec_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_EventZ)); }
- operator LDKCVec_EventZ() && { LDKCVec_EventZ res = self; memset(&self, 0, sizeof(LDKCVec_EventZ)); return res; }
- ~CVec_EventZ() { CVec_EventZ_free(self); }
- CVec_EventZ& operator=(CVec_EventZ&& o) { CVec_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_EventZ)); return *this; }
- LDKCVec_EventZ* operator &() { return &self; }
- LDKCVec_EventZ* operator ->() { return &self; }
- const LDKCVec_EventZ* operator &() const { return &self; }
- const LDKCVec_EventZ* operator ->() const { return &self; }
+ CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
+ CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
+ CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
+ operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
+ ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
+ CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
+ LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
+ LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
+ const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
+ const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
};
-class CResult_NoneSemanticErrorZ {
-private:
- LDKCResult_NoneSemanticErrorZ self;
-public:
- CResult_NoneSemanticErrorZ(const CResult_NoneSemanticErrorZ&) = delete;
- CResult_NoneSemanticErrorZ(CResult_NoneSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); }
- CResult_NoneSemanticErrorZ(LDKCResult_NoneSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); }
- operator LDKCResult_NoneSemanticErrorZ() && { LDKCResult_NoneSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSemanticErrorZ)); return res; }
- ~CResult_NoneSemanticErrorZ() { CResult_NoneSemanticErrorZ_free(self); }
- CResult_NoneSemanticErrorZ& operator=(CResult_NoneSemanticErrorZ&& o) { CResult_NoneSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSemanticErrorZ)); return *this; }
- LDKCResult_NoneSemanticErrorZ* operator &() { return &self; }
- LDKCResult_NoneSemanticErrorZ* operator ->() { return &self; }
- const LDKCResult_NoneSemanticErrorZ* operator &() const { return &self; }
- const LDKCResult_NoneSemanticErrorZ* operator ->() const { return &self; }
+class CVec_C2Tuple_OutPointCVec_u64ZZZ {
+private:
+ LDKCVec_C2Tuple_OutPointCVec_u64ZZZ self;
+public:
+ CVec_C2Tuple_OutPointCVec_u64ZZZ(const CVec_C2Tuple_OutPointCVec_u64ZZZ&) = delete;
+ CVec_C2Tuple_OutPointCVec_u64ZZZ(CVec_C2Tuple_OutPointCVec_u64ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_u64ZZZ)); }
+ CVec_C2Tuple_OutPointCVec_u64ZZZ(LDKCVec_C2Tuple_OutPointCVec_u64ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_u64ZZZ)); }
+ operator LDKCVec_C2Tuple_OutPointCVec_u64ZZZ() && { LDKCVec_C2Tuple_OutPointCVec_u64ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_u64ZZZ)); return res; }
+ ~CVec_C2Tuple_OutPointCVec_u64ZZZ() { CVec_C2Tuple_OutPointCVec_u64ZZZ_free(self); }
+ CVec_C2Tuple_OutPointCVec_u64ZZZ& operator=(CVec_C2Tuple_OutPointCVec_u64ZZZ&& o) { CVec_C2Tuple_OutPointCVec_u64ZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_u64ZZZ)); return *this; }
+ LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_OutPointCVec_u64ZZZ* operator ->() const { return &self; }
+};
+class C2Tuple_ThirtyTwoBytesChannelManagerZ {
+private:
+ LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
+public:
+ C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
+ C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
+ C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
+ operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
+ ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
+ C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
+ LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
+ LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
+ const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
+};
+class CResult_COption_OnionMessageContentsZDecodeErrorZ {
+private:
+ LDKCResult_COption_OnionMessageContentsZDecodeErrorZ self;
+public:
+ CResult_COption_OnionMessageContentsZDecodeErrorZ(const CResult_COption_OnionMessageContentsZDecodeErrorZ&) = delete;
+ CResult_COption_OnionMessageContentsZDecodeErrorZ(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); }
+ CResult_COption_OnionMessageContentsZDecodeErrorZ(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); }
+ operator LDKCResult_COption_OnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_OnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); return res; }
+ ~CResult_COption_OnionMessageContentsZDecodeErrorZ() { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); }
+ CResult_COption_OnionMessageContentsZDecodeErrorZ& operator=(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); return *this; }
+ LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_u64CVec_u8ZZ {
+private:
+ LDKC2Tuple_u64CVec_u8ZZ self;
+public:
+ C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
+ C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
+ C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
+ operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
+ ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
+ C2Tuple_u64CVec_u8ZZ& operator=(C2Tuple_u64CVec_u8ZZ&& o) { C2Tuple_u64CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); return *this; }
+ LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
+ LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
+ const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
+ const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
+};
+class CResult_OfferBolt12ParseErrorZ {
+private:
+ LDKCResult_OfferBolt12ParseErrorZ self;
+public:
+ CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
+ CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
+ CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
+ operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
+ ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
+ CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
+ LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
+ LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
+ const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
+ const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
+};
+class CResult_ThirtyTwoBytesRetryableSendFailureZ {
+private:
+ LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
+public:
+ CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
+ CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
+ CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
+ operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
+ ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
+ CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
+ LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
+ LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
+ const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
+ const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
};
class CVec_MonitorEventZ {
private:
operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
- LDKCVec_MonitorEventZ* operator &() { return &self; }
- LDKCVec_MonitorEventZ* operator ->() { return &self; }
- const LDKCVec_MonitorEventZ* operator &() const { return &self; }
- const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
-};
-class CVec_PaymentPreimageZ {
-private:
- LDKCVec_PaymentPreimageZ self;
-public:
- CVec_PaymentPreimageZ(const CVec_PaymentPreimageZ&) = delete;
- CVec_PaymentPreimageZ(CVec_PaymentPreimageZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PaymentPreimageZ)); }
- CVec_PaymentPreimageZ(LDKCVec_PaymentPreimageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PaymentPreimageZ)); }
- operator LDKCVec_PaymentPreimageZ() && { LDKCVec_PaymentPreimageZ res = self; memset(&self, 0, sizeof(LDKCVec_PaymentPreimageZ)); return res; }
- ~CVec_PaymentPreimageZ() { CVec_PaymentPreimageZ_free(self); }
- CVec_PaymentPreimageZ& operator=(CVec_PaymentPreimageZ&& o) { CVec_PaymentPreimageZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PaymentPreimageZ)); return *this; }
- LDKCVec_PaymentPreimageZ* operator &() { return &self; }
- LDKCVec_PaymentPreimageZ* operator ->() { return &self; }
- const LDKCVec_PaymentPreimageZ* operator &() const { return &self; }
- const LDKCVec_PaymentPreimageZ* operator ->() const { return &self; }
-};
-class CVec_C2Tuple_u32ScriptZZ {
-private:
- LDKCVec_C2Tuple_u32ScriptZZ self;
-public:
- CVec_C2Tuple_u32ScriptZZ(const CVec_C2Tuple_u32ScriptZZ&) = delete;
- CVec_C2Tuple_u32ScriptZZ(CVec_C2Tuple_u32ScriptZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); }
- CVec_C2Tuple_u32ScriptZZ(LDKCVec_C2Tuple_u32ScriptZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); }
- operator LDKCVec_C2Tuple_u32ScriptZZ() && { LDKCVec_C2Tuple_u32ScriptZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32ScriptZZ)); return res; }
- ~CVec_C2Tuple_u32ScriptZZ() { CVec_C2Tuple_u32ScriptZZ_free(self); }
- CVec_C2Tuple_u32ScriptZZ& operator=(CVec_C2Tuple_u32ScriptZZ&& o) { CVec_C2Tuple_u32ScriptZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_u32ScriptZZ)); return *this; }
- LDKCVec_C2Tuple_u32ScriptZZ* operator &() { return &self; }
- LDKCVec_C2Tuple_u32ScriptZZ* operator ->() { return &self; }
- const LDKCVec_C2Tuple_u32ScriptZZ* operator &() const { return &self; }
- const LDKCVec_C2Tuple_u32ScriptZZ* operator ->() const { return &self; }
-};
-class CResult_NoneChannelMonitorUpdateErrZ {
-private:
- LDKCResult_NoneChannelMonitorUpdateErrZ self;
-public:
- CResult_NoneChannelMonitorUpdateErrZ(const CResult_NoneChannelMonitorUpdateErrZ&) = delete;
- CResult_NoneChannelMonitorUpdateErrZ(CResult_NoneChannelMonitorUpdateErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); }
- CResult_NoneChannelMonitorUpdateErrZ(LDKCResult_NoneChannelMonitorUpdateErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); }
- operator LDKCResult_NoneChannelMonitorUpdateErrZ() && { LDKCResult_NoneChannelMonitorUpdateErrZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ)); return res; }
- ~CResult_NoneChannelMonitorUpdateErrZ() { CResult_NoneChannelMonitorUpdateErrZ_free(self); }
- CResult_NoneChannelMonitorUpdateErrZ& operator=(CResult_NoneChannelMonitorUpdateErrZ&& o) { CResult_NoneChannelMonitorUpdateErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneChannelMonitorUpdateErrZ)); return *this; }
- LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() { return &self; }
- LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() { return &self; }
- const LDKCResult_NoneChannelMonitorUpdateErrZ* operator &() const { return &self; }
- const LDKCResult_NoneChannelMonitorUpdateErrZ* operator ->() const { return &self; }
-};
-class CResult_COption_ClosureReasonZDecodeErrorZ {
-private:
- LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
-public:
- CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
- CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
- CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
- operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
- ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
- CResult_COption_ClosureReasonZDecodeErrorZ& operator=(CResult_COption_ClosureReasonZDecodeErrorZ&& o) { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); return *this; }
- LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_PublicKeyErrorZ {
-private:
- LDKCResult_PublicKeyErrorZ self;
-public:
- CResult_PublicKeyErrorZ(const CResult_PublicKeyErrorZ&) = delete;
- CResult_PublicKeyErrorZ(CResult_PublicKeyErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyErrorZ)); }
- CResult_PublicKeyErrorZ(LDKCResult_PublicKeyErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyErrorZ)); }
- operator LDKCResult_PublicKeyErrorZ() && { LDKCResult_PublicKeyErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyErrorZ)); return res; }
- ~CResult_PublicKeyErrorZ() { CResult_PublicKeyErrorZ_free(self); }
- CResult_PublicKeyErrorZ& operator=(CResult_PublicKeyErrorZ&& o) { CResult_PublicKeyErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyErrorZ)); return *this; }
- LDKCResult_PublicKeyErrorZ* operator &() { return &self; }
- LDKCResult_PublicKeyErrorZ* operator ->() { return &self; }
- const LDKCResult_PublicKeyErrorZ* operator &() const { return &self; }
- const LDKCResult_PublicKeyErrorZ* operator ->() const { return &self; }
+ LDKCVec_MonitorEventZ* operator &() { return &self; }
+ LDKCVec_MonitorEventZ* operator ->() { return &self; }
+ const LDKCVec_MonitorEventZ* operator &() const { return &self; }
+ const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
};
-class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
+class CResult_ShutdownDecodeErrorZ {
private:
- LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
+ LDKCResult_ShutdownDecodeErrorZ self;
public:
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
- operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
- ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
- CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ& operator=(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return *this; }
- LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
- LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
- const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
- const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
+ CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
+ CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
+ CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
+ operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
+ ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
+ CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
+ LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
};
-class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
-private:
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
-public:
- C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
- C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
- C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
- operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
- ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
- C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
- LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
- const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
- const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
+class CResult_BigSizeDecodeErrorZ {
+private:
+ LDKCResult_BigSizeDecodeErrorZ self;
+public:
+ CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
+ CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
+ CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
+ operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
+ ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
+ CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
+ LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_TxOutUtxoLookupErrorZ {
+private:
+ LDKCResult_TxOutUtxoLookupErrorZ self;
+public:
+ CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
+ CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
+ CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
+ operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
+ ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
+ CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
+ LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
+ LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
+};
+class COption_usizeZ {
+private:
+ LDKCOption_usizeZ self;
+public:
+ COption_usizeZ(const COption_usizeZ&) = delete;
+ COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
+ COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
+ operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
+ ~COption_usizeZ() { COption_usizeZ_free(self); }
+ COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
+ LDKCOption_usizeZ* operator &() { return &self; }
+ LDKCOption_usizeZ* operator ->() { return &self; }
+ const LDKCOption_usizeZ* operator &() const { return &self; }
+ const LDKCOption_usizeZ* operator ->() const { return &self; }
+};
+class CVec_BlindedMessagePathZ {
+private:
+ LDKCVec_BlindedMessagePathZ self;
+public:
+ CVec_BlindedMessagePathZ(const CVec_BlindedMessagePathZ&) = delete;
+ CVec_BlindedMessagePathZ(CVec_BlindedMessagePathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedMessagePathZ)); }
+ CVec_BlindedMessagePathZ(LDKCVec_BlindedMessagePathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedMessagePathZ)); }
+ operator LDKCVec_BlindedMessagePathZ() && { LDKCVec_BlindedMessagePathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedMessagePathZ)); return res; }
+ ~CVec_BlindedMessagePathZ() { CVec_BlindedMessagePathZ_free(self); }
+ CVec_BlindedMessagePathZ& operator=(CVec_BlindedMessagePathZ&& o) { CVec_BlindedMessagePathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedMessagePathZ)); return *this; }
+ LDKCVec_BlindedMessagePathZ* operator &() { return &self; }
+ LDKCVec_BlindedMessagePathZ* operator ->() { return &self; }
+ const LDKCVec_BlindedMessagePathZ* operator &() const { return &self; }
+ const LDKCVec_BlindedMessagePathZ* operator ->() const { return &self; }
+};
+class CResult_OffersContextDecodeErrorZ {
+private:
+ LDKCResult_OffersContextDecodeErrorZ self;
+public:
+ CResult_OffersContextDecodeErrorZ(const CResult_OffersContextDecodeErrorZ&) = delete;
+ CResult_OffersContextDecodeErrorZ(CResult_OffersContextDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersContextDecodeErrorZ)); }
+ CResult_OffersContextDecodeErrorZ(LDKCResult_OffersContextDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersContextDecodeErrorZ)); }
+ operator LDKCResult_OffersContextDecodeErrorZ() && { LDKCResult_OffersContextDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersContextDecodeErrorZ)); return res; }
+ ~CResult_OffersContextDecodeErrorZ() { CResult_OffersContextDecodeErrorZ_free(self); }
+ CResult_OffersContextDecodeErrorZ& operator=(CResult_OffersContextDecodeErrorZ&& o) { CResult_OffersContextDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersContextDecodeErrorZ)); return *this; }
+ LDKCResult_OffersContextDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OffersContextDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OffersContextDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OffersContextDecodeErrorZ* operator ->() const { return &self; }
};
class CResult_NoneNoneZ {
private:
const LDKCResult_NoneNoneZ* operator &() const { return &self; }
const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
};
-class CResult_RouteParametersDecodeErrorZ {
-private:
- LDKCResult_RouteParametersDecodeErrorZ self;
-public:
- CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
- CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
- CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
- operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
- ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
- CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
- LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
- LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
-};
-class COption_ClosureReasonZ {
-private:
- LDKCOption_ClosureReasonZ self;
-public:
- COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
- COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
- COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
- operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
- ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
- COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
- LDKCOption_ClosureReasonZ* operator &() { return &self; }
- LDKCOption_ClosureReasonZ* operator ->() { return &self; }
- const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
- const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
-};
-class CResult_NodeAliasDecodeErrorZ {
-private:
- LDKCResult_NodeAliasDecodeErrorZ self;
-public:
- CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
- CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
- CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
- operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
- ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
- CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
- LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
- LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
-};
-class CVec_APIErrorZ {
-private:
- LDKCVec_APIErrorZ self;
-public:
- CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
- CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
- CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
- operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
- ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
- CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
- LDKCVec_APIErrorZ* operator &() { return &self; }
- LDKCVec_APIErrorZ* operator ->() { return &self; }
- const LDKCVec_APIErrorZ* operator &() const { return &self; }
- const LDKCVec_APIErrorZ* operator ->() const { return &self; }
-};
-class CResult_PrivateRouteCreationErrorZ {
-private:
- LDKCResult_PrivateRouteCreationErrorZ self;
-public:
- CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
- CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
- CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
- operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
- ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
- CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
- LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
- LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
- const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
- const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
-};
class CResult_boolPeerHandleErrorZ {
private:
LDKCResult_boolPeerHandleErrorZ self;
const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
};
-class CVec_UpdateFulfillHTLCZ {
-private:
- LDKCVec_UpdateFulfillHTLCZ self;
-public:
- CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
- CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
- CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
- operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
- ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
- CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
- LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
- LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
- const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
- const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
-};
-class CResult_BlindedRouteNoneZ {
-private:
- LDKCResult_BlindedRouteNoneZ self;
-public:
- CResult_BlindedRouteNoneZ(const CResult_BlindedRouteNoneZ&) = delete;
- CResult_BlindedRouteNoneZ(CResult_BlindedRouteNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedRouteNoneZ)); }
- CResult_BlindedRouteNoneZ(LDKCResult_BlindedRouteNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedRouteNoneZ)); }
- operator LDKCResult_BlindedRouteNoneZ() && { LDKCResult_BlindedRouteNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedRouteNoneZ)); return res; }
- ~CResult_BlindedRouteNoneZ() { CResult_BlindedRouteNoneZ_free(self); }
- CResult_BlindedRouteNoneZ& operator=(CResult_BlindedRouteNoneZ&& o) { CResult_BlindedRouteNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedRouteNoneZ)); return *this; }
- LDKCResult_BlindedRouteNoneZ* operator &() { return &self; }
- LDKCResult_BlindedRouteNoneZ* operator ->() { return &self; }
- const LDKCResult_BlindedRouteNoneZ* operator &() const { return &self; }
- const LDKCResult_BlindedRouteNoneZ* operator ->() const { return &self; }
-};
-class CResult_AnnouncementSignaturesDecodeErrorZ {
-private:
- LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
-public:
- CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
- CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
- CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
- operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
- ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
- CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
- LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
- LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_UpdateFulfillHTLCDecodeErrorZ {
-private:
- LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
-public:
- CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
- CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
- CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
- operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
- ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
- CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
- LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
- LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
-};
class CResult_ChannelUpdateDecodeErrorZ {
private:
LDKCResult_ChannelUpdateDecodeErrorZ self;
const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_NodeFeaturesDecodeErrorZ {
+class CVec_APIErrorZ {
private:
- LDKCResult_NodeFeaturesDecodeErrorZ self;
+ LDKCVec_APIErrorZ self;
public:
- CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
- CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
- CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
- operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
- ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
- CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
- LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
- LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
+ CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
+ CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
+ CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
+ operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
+ ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
+ CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
+ LDKCVec_APIErrorZ* operator &() { return &self; }
+ LDKCVec_APIErrorZ* operator ->() { return &self; }
+ const LDKCVec_APIErrorZ* operator &() const { return &self; }
+ const LDKCVec_APIErrorZ* operator ->() const { return &self; }
};
-class CVec_u5Z {
+class COption_TxOutZ {
private:
- LDKCVec_u5Z self;
+ LDKCOption_TxOutZ self;
public:
- CVec_u5Z(const CVec_u5Z&) = delete;
- CVec_u5Z(CVec_u5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u5Z)); }
- CVec_u5Z(LDKCVec_u5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u5Z)); }
- operator LDKCVec_u5Z() && { LDKCVec_u5Z res = self; memset(&self, 0, sizeof(LDKCVec_u5Z)); return res; }
- ~CVec_u5Z() { CVec_u5Z_free(self); }
- CVec_u5Z& operator=(CVec_u5Z&& o) { CVec_u5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u5Z)); return *this; }
- LDKCVec_u5Z* operator &() { return &self; }
- LDKCVec_u5Z* operator ->() { return &self; }
- const LDKCVec_u5Z* operator &() const { return &self; }
- const LDKCVec_u5Z* operator ->() const { return &self; }
+ COption_TxOutZ(const COption_TxOutZ&) = delete;
+ COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
+ COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
+ operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
+ ~COption_TxOutZ() { COption_TxOutZ_free(self); }
+ COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
+ LDKCOption_TxOutZ* operator &() { return &self; }
+ LDKCOption_TxOutZ* operator ->() { return &self; }
+ const LDKCOption_TxOutZ* operator &() const { return &self; }
+ const LDKCOption_TxOutZ* operator ->() const { return &self; }
};
-class CResult_InMemorySignerDecodeErrorZ {
+class COption_ClosureReasonZ {
private:
- LDKCResult_InMemorySignerDecodeErrorZ self;
+ LDKCOption_ClosureReasonZ self;
public:
- CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
- CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
- CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
- operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
- ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
- CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
- LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
- LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
+ COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
+ COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
+ COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
+ operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
+ ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
+ COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
+ LDKCOption_ClosureReasonZ* operator &() { return &self; }
+ LDKCOption_ClosureReasonZ* operator ->() { return &self; }
+ const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
+ const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
};
-class CResult_PaymentSecretAPIErrorZ {
-private:
- LDKCResult_PaymentSecretAPIErrorZ self;
-public:
- CResult_PaymentSecretAPIErrorZ(const CResult_PaymentSecretAPIErrorZ&) = delete;
- CResult_PaymentSecretAPIErrorZ(CResult_PaymentSecretAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); }
- CResult_PaymentSecretAPIErrorZ(LDKCResult_PaymentSecretAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); }
- operator LDKCResult_PaymentSecretAPIErrorZ() && { LDKCResult_PaymentSecretAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentSecretAPIErrorZ)); return res; }
- ~CResult_PaymentSecretAPIErrorZ() { CResult_PaymentSecretAPIErrorZ_free(self); }
- CResult_PaymentSecretAPIErrorZ& operator=(CResult_PaymentSecretAPIErrorZ&& o) { CResult_PaymentSecretAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentSecretAPIErrorZ)); return *this; }
- LDKCResult_PaymentSecretAPIErrorZ* operator &() { return &self; }
- LDKCResult_PaymentSecretAPIErrorZ* operator ->() { return &self; }
- const LDKCResult_PaymentSecretAPIErrorZ* operator &() const { return &self; }
- const LDKCResult_PaymentSecretAPIErrorZ* operator ->() const { return &self; }
+class CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ {
+private:
+ LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ self;
+public:
+ CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ(const CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&) = delete;
+ CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); }
+ CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ(LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); }
+ operator LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ() && { LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); return res; }
+ ~CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ() { CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ_free(self); }
+ CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ& operator=(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ&& o) { CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ)); return *this; }
+ LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator &() { return &self; }
+ LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator ->() { return &self; }
+ const LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator &() const { return &self; }
+ const LDKCVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
+private:
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
+public:
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
+ operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
+ ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
+ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ& operator=(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return *this; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
+};
+class CResult_TransactionU16LenLimitedDecodeErrorZ {
+private:
+ LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
+public:
+ CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
+ CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
+ CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
+ operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
+ ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
+ CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
+ LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_FundingInfoDecodeErrorZ {
+private:
+ LDKCResult_FundingInfoDecodeErrorZ self;
+public:
+ CResult_FundingInfoDecodeErrorZ(const CResult_FundingInfoDecodeErrorZ&) = delete;
+ CResult_FundingInfoDecodeErrorZ(CResult_FundingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingInfoDecodeErrorZ)); }
+ CResult_FundingInfoDecodeErrorZ(LDKCResult_FundingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingInfoDecodeErrorZ)); }
+ operator LDKCResult_FundingInfoDecodeErrorZ() && { LDKCResult_FundingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingInfoDecodeErrorZ)); return res; }
+ ~CResult_FundingInfoDecodeErrorZ() { CResult_FundingInfoDecodeErrorZ_free(self); }
+ CResult_FundingInfoDecodeErrorZ& operator=(CResult_FundingInfoDecodeErrorZ&& o) { CResult_FundingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingInfoDecodeErrorZ)); return *this; }
+ LDKCResult_FundingInfoDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_FundingInfoDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_FundingInfoDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_FundingInfoDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_AmountZ {
+private:
+ LDKCOption_AmountZ self;
+public:
+ COption_AmountZ(const COption_AmountZ&) = delete;
+ COption_AmountZ(COption_AmountZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_AmountZ)); }
+ COption_AmountZ(LDKCOption_AmountZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_AmountZ)); }
+ operator LDKCOption_AmountZ() && { LDKCOption_AmountZ res = self; memset(&self, 0, sizeof(LDKCOption_AmountZ)); return res; }
+ ~COption_AmountZ() { COption_AmountZ_free(self); }
+ COption_AmountZ& operator=(COption_AmountZ&& o) { COption_AmountZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_AmountZ)); return *this; }
+ LDKCOption_AmountZ* operator &() { return &self; }
+ LDKCOption_AmountZ* operator ->() { return &self; }
+ const LDKCOption_AmountZ* operator &() const { return &self; }
+ const LDKCOption_AmountZ* operator ->() const { return &self; }
+};
+class COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ {
+private:
+ LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ self;
+public:
+ COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ(const COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&) = delete;
+ COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); }
+ COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ(LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); }
+ operator LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ() && { LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); return res; }
+ ~COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ() { COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ_free(self); }
+ COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ& operator=(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ&& o) { COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ)); return *this; }
+ LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator &() { return &self; }
+ LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator ->() { return &self; }
+ const LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator &() const { return &self; }
+ const LDKCOption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
+private:
+ LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
+public:
+ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
+ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
+ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
+ operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
+ ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
+ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ& operator=(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return *this; }
+ LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
+};
+class CResult_OpenChannelV2DecodeErrorZ {
+private:
+ LDKCResult_OpenChannelV2DecodeErrorZ self;
+public:
+ CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
+ CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
+ CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
+ operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
+ ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
+ CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
+ LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_BestBlockDecodeErrorZ {
+private:
+ LDKCResult_BestBlockDecodeErrorZ self;
+public:
+ CResult_BestBlockDecodeErrorZ(const CResult_BestBlockDecodeErrorZ&) = delete;
+ CResult_BestBlockDecodeErrorZ(CResult_BestBlockDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BestBlockDecodeErrorZ)); }
+ CResult_BestBlockDecodeErrorZ(LDKCResult_BestBlockDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BestBlockDecodeErrorZ)); }
+ operator LDKCResult_BestBlockDecodeErrorZ() && { LDKCResult_BestBlockDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BestBlockDecodeErrorZ)); return res; }
+ ~CResult_BestBlockDecodeErrorZ() { CResult_BestBlockDecodeErrorZ_free(self); }
+ CResult_BestBlockDecodeErrorZ& operator=(CResult_BestBlockDecodeErrorZ&& o) { CResult_BestBlockDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BestBlockDecodeErrorZ)); return *this; }
+ LDKCResult_BestBlockDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BestBlockDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BestBlockDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BestBlockDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
+private:
+ LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
+public:
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
+ operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
+ ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
+ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ& operator=(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return *this; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
+ LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
+ const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
};
class CResult_CounterpartyForwardingInfoDecodeErrorZ {
private:
const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
};
-class COption_ScalarZ {
-private:
- LDKCOption_ScalarZ self;
-public:
- COption_ScalarZ(const COption_ScalarZ&) = delete;
- COption_ScalarZ(COption_ScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ScalarZ)); }
- COption_ScalarZ(LDKCOption_ScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ScalarZ)); }
- operator LDKCOption_ScalarZ() && { LDKCOption_ScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_ScalarZ)); return res; }
- ~COption_ScalarZ() { COption_ScalarZ_free(self); }
- COption_ScalarZ& operator=(COption_ScalarZ&& o) { COption_ScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ScalarZ)); return *this; }
- LDKCOption_ScalarZ* operator &() { return &self; }
- LDKCOption_ScalarZ* operator ->() { return &self; }
- const LDKCOption_ScalarZ* operator &() const { return &self; }
- const LDKCOption_ScalarZ* operator ->() const { return &self; }
-};
-class CResult_SignedRawInvoiceParseErrorZ {
-private:
- LDKCResult_SignedRawInvoiceParseErrorZ self;
-public:
- CResult_SignedRawInvoiceParseErrorZ(const CResult_SignedRawInvoiceParseErrorZ&) = delete;
- CResult_SignedRawInvoiceParseErrorZ(CResult_SignedRawInvoiceParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawInvoiceParseErrorZ)); }
- CResult_SignedRawInvoiceParseErrorZ(LDKCResult_SignedRawInvoiceParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawInvoiceParseErrorZ)); }
- operator LDKCResult_SignedRawInvoiceParseErrorZ() && { LDKCResult_SignedRawInvoiceParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawInvoiceParseErrorZ)); return res; }
- ~CResult_SignedRawInvoiceParseErrorZ() { CResult_SignedRawInvoiceParseErrorZ_free(self); }
- CResult_SignedRawInvoiceParseErrorZ& operator=(CResult_SignedRawInvoiceParseErrorZ&& o) { CResult_SignedRawInvoiceParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawInvoiceParseErrorZ)); return *this; }
- LDKCResult_SignedRawInvoiceParseErrorZ* operator &() { return &self; }
- LDKCResult_SignedRawInvoiceParseErrorZ* operator ->() { return &self; }
- const LDKCResult_SignedRawInvoiceParseErrorZ* operator &() const { return &self; }
- const LDKCResult_SignedRawInvoiceParseErrorZ* operator ->() const { return &self; }
-};
-class CResult_RouteDecodeErrorZ {
-private:
- LDKCResult_RouteDecodeErrorZ self;
-public:
- CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
- CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
- CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
- operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
- ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
- CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
- LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
- LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
-};
-class CResult_BuiltCommitmentTransactionDecodeErrorZ {
-private:
- LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
-public:
- CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
- CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
- CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
- operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
- ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
- CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
- LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
- LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
-};
-class COption_NoneZ {
+class CResult_OutputSpendStatusDecodeErrorZ {
private:
- LDKCOption_NoneZ self;
-public:
- COption_NoneZ(const COption_NoneZ&) = delete;
- COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
- COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
- operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
- ~COption_NoneZ() { COption_NoneZ_free(self); }
- COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
- LDKCOption_NoneZ* operator &() { return &self; }
- LDKCOption_NoneZ* operator ->() { return &self; }
- const LDKCOption_NoneZ* operator &() const { return &self; }
- const LDKCOption_NoneZ* operator ->() const { return &self; }
-};
-class CVec_TxOutZ {
-private:
- LDKCVec_TxOutZ self;
+ LDKCResult_OutputSpendStatusDecodeErrorZ self;
public:
- CVec_TxOutZ(const CVec_TxOutZ&) = delete;
- CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
- CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
- operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
- ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
- CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
- LDKCVec_TxOutZ* operator &() { return &self; }
- LDKCVec_TxOutZ* operator ->() { return &self; }
- const LDKCVec_TxOutZ* operator &() const { return &self; }
- const LDKCVec_TxOutZ* operator ->() const { return &self; }
+ CResult_OutputSpendStatusDecodeErrorZ(const CResult_OutputSpendStatusDecodeErrorZ&) = delete;
+ CResult_OutputSpendStatusDecodeErrorZ(CResult_OutputSpendStatusDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutputSpendStatusDecodeErrorZ)); }
+ CResult_OutputSpendStatusDecodeErrorZ(LDKCResult_OutputSpendStatusDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutputSpendStatusDecodeErrorZ)); }
+ operator LDKCResult_OutputSpendStatusDecodeErrorZ() && { LDKCResult_OutputSpendStatusDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutputSpendStatusDecodeErrorZ)); return res; }
+ ~CResult_OutputSpendStatusDecodeErrorZ() { CResult_OutputSpendStatusDecodeErrorZ_free(self); }
+ CResult_OutputSpendStatusDecodeErrorZ& operator=(CResult_OutputSpendStatusDecodeErrorZ&& o) { CResult_OutputSpendStatusDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutputSpendStatusDecodeErrorZ)); return *this; }
+ LDKCResult_OutputSpendStatusDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_OutputSpendStatusDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_OutputSpendStatusDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_OutputSpendStatusDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_ChannelUpdateInfoDecodeErrorZ {
+class C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ {
private:
- LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
+ LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ self;
public:
- CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
- CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
- CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
- operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
- ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
- CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
- LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
+ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(const C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&) = delete;
+ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); }
+ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); }
+ operator LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ() && { LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); return res; }
+ ~C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ() { C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(self); }
+ C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ& operator=(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ&& o) { C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ)); return *this; }
+ LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
+ LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
+ const LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
+ const LDKC4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
};
-class C2Tuple_u32ScriptZ {
+class CResult_RouteDecodeErrorZ {
private:
- LDKC2Tuple_u32ScriptZ self;
+ LDKCResult_RouteDecodeErrorZ self;
public:
- C2Tuple_u32ScriptZ(const C2Tuple_u32ScriptZ&) = delete;
- C2Tuple_u32ScriptZ(C2Tuple_u32ScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); }
- C2Tuple_u32ScriptZ(LDKC2Tuple_u32ScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); }
- operator LDKC2Tuple_u32ScriptZ() && { LDKC2Tuple_u32ScriptZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32ScriptZ)); return res; }
- ~C2Tuple_u32ScriptZ() { C2Tuple_u32ScriptZ_free(self); }
- C2Tuple_u32ScriptZ& operator=(C2Tuple_u32ScriptZ&& o) { C2Tuple_u32ScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32ScriptZ)); return *this; }
- LDKC2Tuple_u32ScriptZ* operator &() { return &self; }
- LDKC2Tuple_u32ScriptZ* operator ->() { return &self; }
- const LDKC2Tuple_u32ScriptZ* operator &() const { return &self; }
- const LDKC2Tuple_u32ScriptZ* operator ->() const { return &self; }
+ CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
+ CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
+ CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
+ operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
+ ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
+ CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
+ LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
};
-class CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+class CResult_BlindedFailureDecodeErrorZ {
private:
- LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ self;
+ LDKCResult_BlindedFailureDecodeErrorZ self;
public:
- CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&) = delete;
- CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
- CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); }
- operator LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return res; }
- ~CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); }
- CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ& operator=(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ&& o) { CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ)); return *this; }
- LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() { return &self; }
- LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
+ CResult_BlindedFailureDecodeErrorZ(const CResult_BlindedFailureDecodeErrorZ&) = delete;
+ CResult_BlindedFailureDecodeErrorZ(CResult_BlindedFailureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); }
+ CResult_BlindedFailureDecodeErrorZ(LDKCResult_BlindedFailureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); }
+ operator LDKCResult_BlindedFailureDecodeErrorZ() && { LDKCResult_BlindedFailureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); return res; }
+ ~CResult_BlindedFailureDecodeErrorZ() { CResult_BlindedFailureDecodeErrorZ_free(self); }
+ CResult_BlindedFailureDecodeErrorZ& operator=(CResult_BlindedFailureDecodeErrorZ&& o) { CResult_BlindedFailureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); return *this; }
+ LDKCResult_BlindedFailureDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_BlindedFailureDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_BlindedFailureDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_BlindedFailureDecodeErrorZ* operator ->() const { return &self; }
};
-class CVec_UpdateFailHTLCZ {
+class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
private:
- LDKCVec_UpdateFailHTLCZ self;
+ LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
public:
- CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
- CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
- CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
- operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
- ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
- CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
- LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
- LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
- const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
- const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
+ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
+ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
+ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
+ operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
+ ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
+ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return *this; }
+ LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
+ LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
+ const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
+ const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
};
-class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
+class COption_NoneZ {
private:
- LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
+ LDKCOption_NoneZ self;
public:
- CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
- CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
- CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
- operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
- ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
- CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
- LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
- LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
- const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
- const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
+ COption_NoneZ(const COption_NoneZ&) = delete;
+ COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
+ COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
+ operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
+ ~COption_NoneZ() { COption_NoneZ_free(self); }
+ COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
+ LDKCOption_NoneZ* operator &() { return &self; }
+ LDKCOption_NoneZ* operator ->() { return &self; }
+ const LDKCOption_NoneZ* operator &() const { return &self; }
+ const LDKCOption_NoneZ* operator ->() const { return &self; }
+};
+class CResult_SpliceLockedDecodeErrorZ {
+private:
+ LDKCResult_SpliceLockedDecodeErrorZ self;
+public:
+ CResult_SpliceLockedDecodeErrorZ(const CResult_SpliceLockedDecodeErrorZ&) = delete;
+ CResult_SpliceLockedDecodeErrorZ(CResult_SpliceLockedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); }
+ CResult_SpliceLockedDecodeErrorZ(LDKCResult_SpliceLockedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); }
+ operator LDKCResult_SpliceLockedDecodeErrorZ() && { LDKCResult_SpliceLockedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); return res; }
+ ~CResult_SpliceLockedDecodeErrorZ() { CResult_SpliceLockedDecodeErrorZ_free(self); }
+ CResult_SpliceLockedDecodeErrorZ& operator=(CResult_SpliceLockedDecodeErrorZ&& o) { CResult_SpliceLockedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); return *this; }
+ LDKCResult_SpliceLockedDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_SpliceLockedDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_SpliceLockedDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_SpliceLockedDecodeErrorZ* operator ->() const { return &self; }
+};
+class COption_CVec_u8ZZ {
+private:
+ LDKCOption_CVec_u8ZZ self;
+public:
+ COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
+ COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
+ COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
+ operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
+ ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
+ COption_CVec_u8ZZ& operator=(COption_CVec_u8ZZ&& o) { COption_CVec_u8ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CVec_u8ZZ)); return *this; }
+ LDKCOption_CVec_u8ZZ* operator &() { return &self; }
+ LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
+ const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
+ const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
+};
+class COption_QuantityZ {
+private:
+ LDKCOption_QuantityZ self;
+public:
+ COption_QuantityZ(const COption_QuantityZ&) = delete;
+ COption_QuantityZ(COption_QuantityZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_QuantityZ)); }
+ COption_QuantityZ(LDKCOption_QuantityZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_QuantityZ)); }
+ operator LDKCOption_QuantityZ() && { LDKCOption_QuantityZ res = self; memset(&self, 0, sizeof(LDKCOption_QuantityZ)); return res; }
+ ~COption_QuantityZ() { COption_QuantityZ_free(self); }
+ COption_QuantityZ& operator=(COption_QuantityZ&& o) { COption_QuantityZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_QuantityZ)); return *this; }
+ LDKCOption_QuantityZ* operator &() { return &self; }
+ LDKCOption_QuantityZ* operator ->() { return &self; }
+ const LDKCOption_QuantityZ* operator &() const { return &self; }
+ const LDKCOption_QuantityZ* operator ->() const { return &self; }
+};
+class CResult_TxAddOutputDecodeErrorZ {
+private:
+ LDKCResult_TxAddOutputDecodeErrorZ self;
+public:
+ CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
+ CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
+ CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
+ operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
+ ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
+ CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
+ LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
+};
+class CResult_HtlcBasepointDecodeErrorZ {
+private:
+ LDKCResult_HtlcBasepointDecodeErrorZ self;
+public:
+ CResult_HtlcBasepointDecodeErrorZ(const CResult_HtlcBasepointDecodeErrorZ&) = delete;
+ CResult_HtlcBasepointDecodeErrorZ(CResult_HtlcBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); }
+ CResult_HtlcBasepointDecodeErrorZ(LDKCResult_HtlcBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); }
+ operator LDKCResult_HtlcBasepointDecodeErrorZ() && { LDKCResult_HtlcBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); return res; }
+ ~CResult_HtlcBasepointDecodeErrorZ() { CResult_HtlcBasepointDecodeErrorZ_free(self); }
+ CResult_HtlcBasepointDecodeErrorZ& operator=(CResult_HtlcBasepointDecodeErrorZ&& o) { CResult_HtlcBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); return *this; }
+ LDKCResult_HtlcBasepointDecodeErrorZ* operator &() { return &self; }
+ LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() { return &self; }
+ const LDKCResult_HtlcBasepointDecodeErrorZ* operator &() const { return &self; }
+ const LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() const { return &self; }
+};
+class C2Tuple_OutPointChannelIdZ {
+private:
+ LDKC2Tuple_OutPointChannelIdZ self;
+public:
+ C2Tuple_OutPointChannelIdZ(const C2Tuple_OutPointChannelIdZ&) = delete;
+ C2Tuple_OutPointChannelIdZ(C2Tuple_OutPointChannelIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointChannelIdZ)); }
+ C2Tuple_OutPointChannelIdZ(LDKC2Tuple_OutPointChannelIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointChannelIdZ)); }
+ operator LDKC2Tuple_OutPointChannelIdZ() && { LDKC2Tuple_OutPointChannelIdZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointChannelIdZ)); return res; }
+ ~C2Tuple_OutPointChannelIdZ() { C2Tuple_OutPointChannelIdZ_free(self); }
+ C2Tuple_OutPointChannelIdZ& operator=(C2Tuple_OutPointChannelIdZ&& o) { C2Tuple_OutPointChannelIdZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointChannelIdZ)); return *this; }
+ LDKC2Tuple_OutPointChannelIdZ* operator &() { return &self; }
+ LDKC2Tuple_OutPointChannelIdZ* operator ->() { return &self; }
+ const LDKC2Tuple_OutPointChannelIdZ* operator &() const { return &self; }
+ const LDKC2Tuple_OutPointChannelIdZ* operator ->() const { return &self; }
};
-inline void BroadcasterInterface::broadcast_transaction(struct LDKTransaction tx) {
- (self.broadcast_transaction)(self.this_arg, tx);
-}
-inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
- uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
+inline LDK::CResult_SchnorrSignatureNoneZ SignBolt12InvoiceFn::sign_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR message) {
+ LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, message);
return ret;
}
-inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
- LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
+inline LDK::CResult_PublicKeyNoneZ ChannelSigner::get_per_commitment_point(uint64_t idx) {
+ LDK::CResult_PublicKeyNoneZ ret = (self.get_per_commitment_point)(self.this_arg, idx);
return ret;
}
-inline LDK::OnionMessage OnionMessageProvider::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
- LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
+inline LDK::CResult__u832NoneZ ChannelSigner::release_commitment_secret(uint64_t idx) {
+ LDK::CResult__u832NoneZ ret = (self.release_commitment_secret)(self.this_arg, idx);
return ret;
}
-inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
- (self.process_pending_events)(self.this_arg, handler);
-}
-inline void EventHandler::handle_event(const struct LDKEvent *NONNULL_PTR event) {
- (self.handle_event)(self.this_arg, event);
-}
-inline LDK::CResult_TxOutAccessErrorZ Access::get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id) {
- LDK::CResult_TxOutAccessErrorZ ret = (self.get_utxo)(self.this_arg, genesis_hash, short_channel_id);
+inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
+ LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, outbound_htlc_preimages);
return ret;
}
-inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
- (self.filtered_block_connected)(self.this_arg, header, txdata, height);
-}
-inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
- (self.block_connected)(self.this_arg, block, height);
-}
-inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
- (self.block_disconnected)(self.this_arg, header, height);
-}
-inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
- (self.transactions_confirmed)(self.this_arg, header, txdata, height);
+inline LDK::CResult_NoneNoneZ ChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
+ LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
+ return ret;
}
-inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
- (self.transaction_unconfirmed)(self.this_arg, txid);
+inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
+ LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
+ return ret;
}
-inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
- (self.best_block_updated)(self.this_arg, header, height);
+inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
+ (self.provide_channel_parameters)(self.this_arg, channel_parameters);
}
-inline LDK::CVec_TxidZ Confirm::get_relevant_txids() {
- LDK::CVec_TxidZ ret = (self.get_relevant_txids)(self.this_arg);
+inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
+ LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
return ret;
}
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
- LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
+inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
+ LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
return ret;
}
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Watch::update_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update) {
- LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_channel)(self.this_arg, funding_txo, update);
+inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
+ LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
return ret;
}
-inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
- LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
+inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
+ LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
return ret;
}
-inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
- (self.register_tx)(self.this_arg, txid, script_pubkey);
-}
-inline void Filter::register_output(struct LDKWatchedOutput output) {
- (self.register_output)(self.this_arg, output);
-}
-inline uint64_t Score::channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage) {
- uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage);
+inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(const struct LDKRawBolt11Invoice *NONNULL_PTR invoice, enum LDKRecipient recipient) {
+ LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, invoice, recipient);
return ret;
}
-inline void Score::payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
- (self.payment_path_failed)(self.this_arg, path, short_channel_id);
-}
-inline void Score::payment_path_successful(struct LDKCVec_RouteHopZ path) {
- (self.payment_path_successful)(self.this_arg, path);
-}
-inline void Score::probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
- (self.probe_failed)(self.this_arg, path, short_channel_id);
-}
-inline void Score::probe_successful(struct LDKCVec_RouteHopZ path) {
- (self.probe_successful)(self.this_arg, path);
+inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
+ LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
+ return ret;
}
-inline LDK::Score LockableScore::lock() {
- LDK::Score ret = (self.lock)(self.this_arg);
+inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
+ LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
return ret;
}
-inline LDKPublicKey BaseSign::get_per_commitment_point(uint64_t idx) {
- LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
+inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
return ret;
}
-inline LDKThirtyTwoBytes BaseSign::release_commitment_secret(uint64_t idx) {
- LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
+inline LDK::CResult_TransactionNoneZ OutputSpender::spend_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight, struct LDKCOption_u32Z locktime) {
+ LDK::CResult_TransactionNoneZ ret = (self.spend_spendable_outputs)(self.this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight, locktime);
return ret;
}
-inline LDK::CResult_NoneNoneZ BaseSign::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages) {
- LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
+inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
+ LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
return ret;
}
-inline LDKThirtyTwoBytes BaseSign::channel_keys_id() {
- LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
+inline LDK::EcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
+ LDK::EcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
return ret;
}
-inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages) {
- LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
+inline LDK::CResult_EcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
+ LDK::CResult_EcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
return ret;
}
-inline LDK::CResult_NoneNoneZ BaseSign::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
- LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
+inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script(struct LDKThirtyTwoBytes channel_keys_id) {
+ LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg, channel_keys_id);
return ret;
}
-inline LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
- LDK::CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, commitment_tx);
+inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
+ LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
return ret;
}
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
- LDK::CResult_SignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
+inline LDK::CResult_CVec_u8ZNoneZ ChangeDestinationSource::get_change_destination_script() {
+ LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_destination_script)(self.this_arg);
return ret;
}
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
- LDK::CResult_SignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
+inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs) {
+ LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
return ret;
}
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
- LDK::CResult_SignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
+inline LDK::CResult_RouteLightningErrorZ Router::find_route_with_id(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs, struct LDKThirtyTwoBytes _payment_hash, struct LDKThirtyTwoBytes _payment_id) {
+ LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
return ret;
}
-inline LDK::CResult_SignatureNoneZ BaseSign::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
- LDK::CResult_SignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
+inline LDK::CResult_CVec_BlindedPaymentPathZNoneZ Router::create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats) {
+ LDK::CResult_CVec_BlindedPaymentPathZNoneZ ret = (self.create_blinded_payment_paths)(self.this_arg, recipient, first_hops, tlvs, amount_msats);
return ret;
}
-inline LDK::CResult_C2Tuple_SignatureSignatureZNoneZ BaseSign::sign_channel_announcement(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
- LDK::CResult_C2Tuple_SignatureSignatureZNoneZ ret = (self.sign_channel_announcement)(self.this_arg, msg);
+inline uint64_t ScoreLookUp::channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
+ uint64_t ret = (self.channel_penalty_msat)(self.this_arg, candidate, usage, score_params);
return ret;
}
-inline void BaseSign::ready_channel(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
- (self.ready_channel)(self.this_arg, channel_parameters);
+inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
+ (self.payment_path_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
}
-inline LDK::CResult_SecretKeyNoneZ KeysInterface::get_node_secret(enum LDKRecipient recipient) {
- LDK::CResult_SecretKeyNoneZ ret = (self.get_node_secret)(self.this_arg, recipient);
- return ret;
+inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
+ (self.payment_path_successful)(self.this_arg, path, duration_since_epoch);
}
-inline LDK::CResult_SharedSecretNoneZ KeysInterface::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_ScalarZ tweak) {
- LDK::CResult_SharedSecretNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
- return ret;
+inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
+ (self.probe_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
}
-inline LDK::CVec_u8Z KeysInterface::get_destination_script() {
- LDK::CVec_u8Z ret = (self.get_destination_script)(self.this_arg);
- return ret;
+inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
+ (self.probe_successful)(self.this_arg, path, duration_since_epoch);
+}
+inline void ScoreUpdate::time_passed(uint64_t duration_since_epoch) {
+ (self.time_passed)(self.this_arg, duration_since_epoch);
}
-inline LDK::ShutdownScript KeysInterface::get_shutdown_scriptpubkey() {
- LDK::ShutdownScript ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
+inline LDK::ScoreLookUp LockableScore::read_lock() {
+ LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
return ret;
}
-inline LDK::Sign KeysInterface::get_channel_signer(bool inbound, uint64_t channel_value_satoshis) {
- LDK::Sign ret = (self.get_channel_signer)(self.this_arg, inbound, channel_value_satoshis);
+inline LDK::ScoreUpdate LockableScore::write_lock() {
+ LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
return ret;
}
-inline LDKThirtyTwoBytes KeysInterface::get_secure_random_bytes() {
- LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
+inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
+ (self.filtered_block_connected)(self.this_arg, header, txdata, height);
+}
+inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
+ (self.block_connected)(self.this_arg, block, height);
+}
+inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
+ (self.block_disconnected)(self.this_arg, header, height);
+}
+inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
+ (self.transactions_confirmed)(self.this_arg, header, txdata, height);
+}
+inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
+ (self.transaction_unconfirmed)(self.this_arg, txid);
+}
+inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
+ (self.best_block_updated)(self.this_arg, header, height);
+}
+inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
+ LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
return ret;
}
-inline LDK::CResult_SignDecodeErrorZ KeysInterface::read_chan_signer(struct LDKu8slice reader) {
- LDK::CResult_SignDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
+inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
+ LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
return ret;
}
-inline LDK::CResult_RecoverableSignatureNoneZ KeysInterface::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient) {
- LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, receipient);
+inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
+ LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
return ret;
}
-inline LDKThirtyTwoBytes KeysInterface::get_inbound_payment_key_material() {
- LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
+inline LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
+ LDK::CVec_C4Tuple_OutPointChannelIdCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
return ret;
}
-inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
- LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
+inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
+ (self.register_tx)(self.this_arg, txid, script_pubkey);
+}
+inline void Filter::register_output(struct LDKWatchedOutput output) {
+ (self.register_output)(self.this_arg, output);
+}
+inline LDK::CResult_CoinSelectionNoneZ CoinSelectionSource::select_confirmed_utxos(struct LDKThirtyTwoBytes claim_id, struct LDKCVec_InputZ must_spend, struct LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight) {
+ LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
return ret;
}
-inline uint16_t Type::type_id() {
- uint16_t ret = (self.type_id)(self.this_arg);
+inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_psbt(struct LDKCVec_u8Z psbt) {
+ LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
return ret;
}
-inline LDK::Str Type::debug_str() {
- LDK::Str ret = (self.debug_str)(self.this_arg);
+inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
+ LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
return ret;
}
-inline LDKPublicKey Payer::node_id() {
- LDKPublicKey ret = (self.node_id)(self.this_arg);
+inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
+ LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
return ret;
}
-inline LDK::CVec_ChannelDetailsZ Payer::first_hops() {
- LDK::CVec_ChannelDetailsZ ret = (self.first_hops)(self.this_arg);
+inline LDK::CResult_TransactionNoneZ WalletSource::sign_psbt(struct LDKCVec_u8Z psbt) {
+ LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
return ret;
}
-inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret) {
- LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_payment)(self.this_arg, route, payment_hash, payment_secret);
+inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
+ LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
return ret;
}
-inline LDK::CResult_PaymentIdPaymentSendFailureZ Payer::send_spontaneous_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage) {
- LDK::CResult_PaymentIdPaymentSendFailureZ ret = (self.send_spontaneous_payment)(self.this_arg, route, payment_preimage);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
return ret;
}
-inline LDK::CResult_NonePaymentSendFailureZ Payer::retry_payment(const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id) {
- LDK::CResult_NonePaymentSendFailureZ ret = (self.retry_payment)(self.this_arg, route, payment_id);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_output(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32]) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
return ret;
}
-inline void Payer::abandon_payment(struct LDKThirtyTwoBytes payment_id) {
- (self.abandon_payment)(self.this_arg, payment_id);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_justice_revoked_htlc(struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
+ return ret;
}
-inline LDK::CResult_RouteLightningErrorZ Router::find_route(struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKInFlightHtlcs inflight_htlcs) {
- LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, payment_hash, first_hops, inflight_htlcs);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
return ret;
}
-inline void Router::notify_payment_path_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
- (self.notify_payment_path_failed)(self.this_arg, path, short_channel_id);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_counterparty_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
+ return ret;
}
-inline void Router::notify_payment_path_successful(struct LDKCVec_RouteHopZ path) {
- (self.notify_payment_path_successful)(self.this_arg, path);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
+ return ret;
}
-inline void Router::notify_payment_probe_successful(struct LDKCVec_RouteHopZ path) {
- (self.notify_payment_probe_successful)(self.this_arg, path);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
+ return ret;
}
-inline void Router::notify_payment_probe_failed(struct LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
- (self.notify_payment_probe_failed)(self.this_arg, path, short_channel_id);
+inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
+ LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
+ return ret;
}
inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
return ret;
}
+inline void CustomMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
+ (self.peer_disconnected)(self.this_arg, their_node_id);
+}
+inline LDK::CResult_NoneNoneZ CustomMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
+ LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
+ return ret;
+}
+inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
+ LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
+ return ret;
+}
+inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
+ LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
+ return ret;
+}
inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
return ret;
uint64_t ret = (self.hash)(self.this_arg);
return ret;
}
-inline LDK::CResult_NoneErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
- LDK::CResult_NoneErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
+inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
+ LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
+ return ret;
+}
+inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
+ LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
+ return ret;
+}
+inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
+ LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
return ret;
}
-inline LDK::CResult_NoneErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
- LDK::CResult_NoneErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
+inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
+ LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
return ret;
}
-inline LDK::CResult_NoneErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
- LDK::CResult_NoneErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
+inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
+ LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
return ret;
}
-inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg) {
- (self.handle_open_channel)(self.this_arg, their_node_id, their_features, msg);
+inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
+ LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
+ return ret;
+}
+inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
+ LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
+ return ret;
+}
+inline LDK::CResult_SchnorrSignatureNoneZ SignInvoiceRequestFn::sign_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR message) {
+ LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_invoice_request)(self.this_arg, message);
+ return ret;
+}
+inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
+ (self.handle_open_channel)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
+ (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
+ (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
}
-inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg) {
- (self.handle_accept_channel)(self.this_arg, their_node_id, their_features, msg);
+inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
+ (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
}
inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
(self.handle_funding_created)(self.this_arg, their_node_id, msg);
inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
(self.handle_channel_ready)(self.this_arg, their_node_id, msg);
}
-inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg) {
- (self.handle_shutdown)(self.this_arg, their_node_id, their_features, msg);
+inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
+ (self.handle_shutdown)(self.this_arg, their_node_id, msg);
}
inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
(self.handle_closing_signed)(self.this_arg, their_node_id, msg);
}
+inline void ChannelMessageHandler::handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg) {
+ (self.handle_stfu)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
+ (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
+ (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
+ (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
+ (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
+ (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
+ (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
+ (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
+ (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
+}
+inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
+ (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
+}
inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
(self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
}
inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
(self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
}
-inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible) {
- (self.peer_disconnected)(self.this_arg, their_node_id, no_connection_possible);
+inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
+ (self.peer_disconnected)(self.this_arg, their_node_id);
}
-inline void ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg) {
- (self.peer_connected)(self.this_arg, their_node_id, msg);
+inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
+ LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
+ return ret;
}
inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
(self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
return ret;
}
+inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_chain_hashes() {
+ LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_chain_hashes)(self.this_arg);
+ return ret;
+}
inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
return ret;
LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
return ret;
}
-inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKPublicKey starting_point) {
+inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
return ret;
}
-inline void RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init) {
- (self.peer_connected)(self.this_arg, their_node_id, init);
+inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
+ LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
+ return ret;
}
inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
return ret;
}
+inline bool RoutingMessageHandler::processing_queue_high() {
+ bool ret = (self.processing_queue_high)(self.this_arg);
+ return ret;
+}
inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
return ret;
inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
(self.handle_onion_message)(self.this_arg, peer_node_id, msg);
}
-inline void OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init) {
- (self.peer_connected)(self.this_arg, their_node_id, init);
+inline LDK::OnionMessage OnionMessageHandler::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
+ LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
+ return ret;
+}
+inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
+ LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
+ return ret;
}
-inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id, bool no_connection_possible) {
- (self.peer_disconnected)(self.this_arg, their_node_id, no_connection_possible);
+inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
+ (self.peer_disconnected)(self.this_arg, their_node_id);
+}
+inline void OnionMessageHandler::timer_tick_occurred() {
+ (self.timer_tick_occurred)(self.this_arg);
}
inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
return ret;
}
-inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
+inline void Logger::log(struct LDKRecord record) {
(self.log)(self.this_arg, record);
}
inline void FutureCallback::call() {
(self.call)(self.this_arg);
}
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
- LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
+inline LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ AsyncPaymentsMessageHandler::held_htlc_available(struct LDKHeldHtlcAvailable message, struct LDKResponder responder) {
+ LDK::COption_C2Tuple_ReleaseHeldHtlcResponseInstructionZZ ret = (self.held_htlc_available)(self.this_arg, message, responder);
+ return ret;
+}
+inline void AsyncPaymentsMessageHandler::release_held_htlc(struct LDKReleaseHeldHtlc message) {
+ (self.release_held_htlc)(self.this_arg, message);
+}
+inline LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ AsyncPaymentsMessageHandler::release_pending_messages() {
+ LDK::CVec_C2Tuple_AsyncPaymentsMessageMessageSendInstructionsZZ ret = (self.release_pending_messages)(self.this_arg);
+ return ret;
+}
+inline LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ OffersMessageHandler::handle_message(struct LDKOffersMessage message, struct LDKCOption_OffersContextZ context, struct LDKResponder responder) {
+ LDK::COption_C2Tuple_OffersMessageResponseInstructionZZ ret = (self.handle_message)(self.this_arg, message, context, responder);
+ return ret;
+}
+inline LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ OffersMessageHandler::release_pending_messages() {
+ LDK::CVec_C2Tuple_OffersMessageMessageSendInstructionsZZ ret = (self.release_pending_messages)(self.this_arg);
+ return ret;
+}
+inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
+ (self.broadcast_transactions)(self.this_arg, txs);
+}
+inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
+ uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
+ return ret;
+}
+inline uint64_t OnionMessageContents::tlv_type() {
+ uint64_t ret = (self.tlv_type)(self.this_arg);
+ return ret;
+}
+inline LDK::Str OnionMessageContents::msg_type() {
+ LDK::Str ret = (self.msg_type)(self.this_arg);
+ return ret;
+}
+inline LDK::Str OnionMessageContents::debug_str() {
+ LDK::Str ret = (self.debug_str)(self.this_arg);
+ return ret;
+}
+inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
+ LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
+ return ret;
+}
+inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
+ (self.process_pending_events)(self.this_arg, handler);
+}
+inline LDK::CResult_NoneReplayEventZ EventHandler::handle_event(struct LDKEvent event) {
+ LDK::CResult_NoneReplayEventZ ret = (self.handle_event)(self.this_arg, event);
+ return ret;
+}
+inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
+ LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
+ return ret;
+}
+inline uint16_t Type::type_id() {
+ uint16_t ret = (self.type_id)(self.this_arg);
+ return ret;
+}
+inline LDK::Str Type::debug_str() {
+ LDK::Str ret = (self.debug_str)(self.this_arg);
+ return ret;
+}
+inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id) {
+ LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, chain_hash, short_channel_id);
+ return ret;
+}
+inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
+ LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
+ return ret;
+}
+inline LDK::CResult_CVec_BlindedMessagePathZNoneZ MessageRouter::create_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_PublicKeyZ peers) {
+ LDK::CResult_CVec_BlindedMessagePathZNoneZ ret = (self.create_blinded_paths)(self.this_arg, recipient, context, peers);
+ return ret;
+}
+inline LDK::CResult_CVec_BlindedMessagePathZNoneZ MessageRouter::create_compact_blinded_paths(struct LDKPublicKey recipient, struct LDKMessageContext context, struct LDKCVec_MessageForwardNodeZ peers) {
+ LDK::CResult_CVec_BlindedMessagePathZNoneZ ret = (self.create_compact_blinded_paths)(self.this_arg, recipient, context, peers);
+ return ret;
+}
+inline LDK::COption_C2Tuple_OnionMessageContentsResponseInstructionZZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents message, struct LDKCOption_CVec_u8ZZ context, struct LDKResponder responder) {
+ LDK::COption_C2Tuple_OnionMessageContentsResponseInstructionZZ ret = (self.handle_custom_message)(self.this_arg, message, context, responder);
+ return ret;
+}
+inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
+ LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
+ return ret;
+}
+inline LDK::CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ CustomOnionMessageHandler::release_pending_custom_messages() {
+ LDK::CVec_C2Tuple_OnionMessageContentsMessageSendInstructionsZZ ret = (self.release_pending_custom_messages)(self.this_arg);
+ return ret;
+}
+inline LDKPublicKey NodeIdLookUp::next_node_id(uint64_t short_channel_id) {
+ LDKPublicKey ret = (self.next_node_id)(self.this_arg, short_channel_id);
+ return ret;
+}
+inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_funding_outpoint, const struct LDKChannelMonitor *NONNULL_PTR monitor) {
+ LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_funding_outpoint, monitor);
return ret;
}
-inline LDK::CResult_NoneChannelMonitorUpdateErrZ Persist::update_persisted_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
- LDK::CResult_NoneChannelMonitorUpdateErrZ ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);
+inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_funding_outpoint, struct LDKChannelMonitorUpdate monitor_update, const struct LDKChannelMonitor *NONNULL_PTR monitor) {
+ LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_funding_outpoint, monitor_update, monitor);
return ret;
}
+inline void Persist::archive_persisted_channel(struct LDKOutPoint channel_funding_outpoint) {
+ (self.archive_persisted_channel)(self.this_arg, channel_funding_outpoint);
+}
}