3 // Forward declarations
7 class RetryableSendFailure;
8 class PaymentSendFailure;
9 class ProbeSendFailure;
10 class RecipientOnionFields;
11 class UnsignedBolt12Invoice;
14 class DelayedPaymentOutputDescriptor;
15 class StaticPaymentOutputDescriptor;
16 class SpendableOutputDescriptor;
18 class EcdsaChannelSigner;
19 class WriteableEcdsaChannelSigner;
26 class PhantomKeysManager;
27 class BackgroundProcessor;
31 class ScorerAccountingForInFlightHtlcs;
37 class RouteParameters;
38 class PaymentParameters;
47 class MultiThreadedLockableScore;
48 class MultiThreadedScoreLockRead;
49 class MultiThreadedScoreLockWrite;
51 class FixedPenaltyScorer;
52 class ProbabilisticScorer;
53 class ProbabilisticScoringFeeParameters;
54 class ProbabilisticScoringDecayParameters;
58 class ChannelMonitorUpdateStatus;
64 class ChannelFeatures;
65 class Bolt11InvoiceFeatures;
67 class InvoiceRequestFeatures;
68 class Bolt12InvoiceFeatures;
69 class BlindedHopFeatures;
70 class ChannelTypeFeatures;
76 class ReadOnlyNetworkGraph;
79 class ChannelUpdateInfo;
81 class DirectedChannelInfo;
82 class EffectiveCapacity;
84 class NodeAnnouncementInfo;
87 class ChannelDerivationParameters;
88 class AnchorDescriptor;
90 class BumpTransactionEvent;
94 class CoinSelectionSource;
97 class BumpTransactionEventHandler;
100 class ChainParameters;
101 class CounterpartyForwardingInfo;
102 class ChannelCounterparty;
103 class ChannelDetails;
104 class ChannelShutdownState;
105 class RecentPaymentDetails;
106 class PhantomRouteHints;
107 class ChannelManagerReadArgs;
108 class ChannelHandshakeConfig;
109 class ChannelHandshakeLimits;
110 class MaxDustHTLCExposure;
112 class ChannelConfigUpdate;
116 class ChannelMonitorUpdate;
120 class ChannelMonitor;
122 class CustomMessageHandler;
123 class IgnoringMessageHandler;
124 class ErroringMessageHandler;
125 class MessageHandler;
126 class SocketDescriptor;
127 class PeerHandleError;
129 class RapidGossipSync;
132 class MonitorUpdatingPersister;
133 class UnsignedInvoiceRequest;
134 class InvoiceRequest;
135 class VerifiedInvoiceRequest;
139 class WarningMessage;
145 class AcceptChannelV2;
146 class FundingCreated;
152 class TxRemoveOutput;
159 class ClosingSignedFeeRange;
163 class UpdateFulfillHTLC;
164 class UpdateFailHTLC;
165 class UpdateFailMalformedHTLC;
166 class CommitmentSigned;
169 class ChannelReestablish;
170 class AnnouncementSignatures;
172 class SocketAddressParseError;
173 class UnsignedGossipMessage;
174 class UnsignedNodeAnnouncement;
175 class NodeAnnouncement;
176 class UnsignedChannelAnnouncement;
177 class ChannelAnnouncement;
178 class UnsignedChannelUpdate;
180 class QueryChannelRange;
181 class ReplyChannelRange;
182 class QueryShortChannelIds;
183 class ReplyShortChannelIdsEnd;
184 class GossipTimestampFilter;
186 class LightningError;
187 class CommitmentUpdate;
188 class ChannelMessageHandler;
189 class RoutingMessageHandler;
190 class OnionMessageHandler;
194 class FutureCallback;
197 class OffersMessageHandler;
200 class CounterpartyCommitmentSecrets;
201 class TxCreationKeys;
202 class ChannelPublicKeys;
203 class HTLCOutputInCommitment;
204 class ChannelTransactionParameters;
205 class CounterpartyChannelTransactionParameters;
206 class DirectedChannelTransactionParameters;
207 class HolderCommitmentTransaction;
208 class BuiltCommitmentTransaction;
209 class ClosingTransaction;
210 class TrustedClosingTransaction;
211 class CommitmentTransaction;
212 class TrustedCommitmentTransaction;
213 class ShutdownScript;
214 class InvalidShutdownScript;
215 class Bolt12ParseError;
216 class Bolt12SemanticError;
217 class BroadcasterInterface;
218 class ConfirmationTarget;
221 class OnionMessageContents;
222 class CustomOnionMessageContents;
223 class PaymentPurpose;
227 class HTLCDestination;
228 class PaymentFailureReason;
230 class MessageSendEvent;
231 class MessageSendEventsProvider;
232 class OnionMessageProvider;
233 class EventsProvider;
235 class Bolt11ParseError;
236 class ParseOrSemanticError;
238 class SignedRawBolt11Invoice;
239 class RawBolt11Invoice;
241 class PositiveTimestamp;
248 class MinFinalCltvExpiryDelta;
250 class Bolt11InvoiceSignature;
253 class Bolt11SemanticError;
254 class SignOrCreationError;
258 class TransactionU16LenLimited;
259 class UntrustedString;
260 class PrintableString;
261 class CustomMessageReader;
267 class PaymentConstraints;
270 class UtxoLookupError;
274 class OnionMessenger;
276 class DefaultMessageRouter;
277 class OnionMessagePath;
280 class CustomOnionMessageHandler;
281 class FilesystemStore;
284 class GraphSyncError;
286 class ErroneousField;
287 class MonitorUpdateId;
289 class LockedChannelMonitor;
291 class CResult_LockedChannelMonitorNoneZ;
292 class CResult_TransactionU16LenLimitedNoneZ;
293 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
294 class CResult_PhantomRouteHintsDecodeErrorZ;
295 class CResult_FundingCreatedDecodeErrorZ;
296 class CVec_C2Tuple_u32TxOutZZ;
297 class CResult_RetryDecodeErrorZ;
298 class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ;
299 class CResult_ChannelInfoDecodeErrorZ;
300 class COption_MaxDustHTLCExposureZ;
301 class CResult_NoneSendErrorZ;
302 class C2Tuple_CVec_u8ZusizeZ;
303 class COption_OffersMessageZ;
304 class COption_NetworkUpdateZ;
306 class CResult_CVec_u8ZPeerHandleErrorZ;
307 class CResult_GossipTimestampFilterDecodeErrorZ;
308 class CResult_RouteHintDecodeErrorZ;
309 class COption_FilterZ;
310 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
311 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
312 class CResult_COption_APIErrorZDecodeErrorZ;
313 class CVec_UpdateAddHTLCZ;
314 class CResult_TxAbortDecodeErrorZ;
315 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
317 class CResult_RecipientOnionFieldsNoneZ;
318 class C2Tuple__u1632_u1632Z;
319 class CResult_CVec_StrZIOErrorZ;
320 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
321 class CResult_TransactionNoneZ;
322 class CResult_CommitmentSignedDecodeErrorZ;
323 class CResult_CommitmentTransactionDecodeErrorZ;
324 class CResult_ErrorMessageDecodeErrorZ;
325 class CResult_OpenChannelDecodeErrorZ;
326 class COption_APIErrorZ;
327 class CResult_QueryChannelRangeDecodeErrorZ;
328 class CVec_TransactionZ;
330 class CResult_ChannelFeaturesDecodeErrorZ;
331 class CResult_ChannelReadyDecodeErrorZ;
332 class CResult_UpdateFeeDecodeErrorZ;
333 class CResult_NoneBolt11SemanticErrorZ;
334 class CResult_NoneRetryableSendFailureZ;
335 class CResult_boolLightningErrorZ;
336 class CResult_NodeIdDecodeErrorZ;
337 class CResult_ChannelShutdownStateDecodeErrorZ;
338 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
339 class CResult_NodeAnnouncementInfoDecodeErrorZ;
340 class CResult_ShutdownScriptInvalidShutdownScriptZ;
341 class CResult_COption_NetworkUpdateZDecodeErrorZ;
342 class CVec_UpdateFailMalformedHTLCZ;
343 class CResult_ShutdownScriptNoneZ;
344 class COption_HTLCDestinationZ;
345 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
346 class CVec_RouteHopZ;
347 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
348 class CResult_CVec_UtxoZNoneZ;
349 class CResult_CVec_u8ZIOErrorZ;
350 class COption_CustomOnionMessageContentsZ;
351 class CVec_ThirtyTwoBytesZ;
352 class CResult_ChannelMonitorUpdateStatusNoneZ;
353 class CResult_ClosingSignedDecodeErrorZ;
354 class CResult_NonePaymentErrorZ;
355 class CVec_CResult_NoneAPIErrorZZ;
356 class CResult_SchnorrSignatureNoneZ;
357 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
358 class CResult_ReceiveTlvsDecodeErrorZ;
359 class CResult_HTLCDescriptorDecodeErrorZ;
360 class CVec_RecentPaymentDetailsZ;
361 class CVec_RouteHintHopZ;
362 class CResult_UntrustedStringDecodeErrorZ;
364 class CResult_PaymentParametersDecodeErrorZ;
365 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
367 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
368 class CResult_TxAckRbfDecodeErrorZ;
369 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
370 class COption_UtxoLookupZ;
371 class CResult_PongDecodeErrorZ;
372 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
373 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
374 class CResult_CVec_u8ZNoneZ;
375 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
376 class CResult_ChannelTransactionParametersDecodeErrorZ;
377 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
378 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
379 class CResult_InFlightHtlcsDecodeErrorZ;
380 class CResult_COption_HTLCDestinationZDecodeErrorZ;
381 class CResult_ThirtyTwoBytesNoneZ;
382 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
383 class CResult_BlindedHopDecodeErrorZ;
384 class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ;
385 class CResult_FixedPenaltyScorerDecodeErrorZ;
386 class CVec_BlindedPathZ;
387 class CResult_NoneLightningErrorZ;
388 class CResult_NonePeerHandleErrorZ;
389 class CResult_TrustedCommitmentTransactionNoneZ;
390 class CResult_COption_EventZDecodeErrorZ;
391 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ;
392 class CResult_PaymentFailureReasonDecodeErrorZ;
393 class COption_SocketAddressZ;
394 class CResult_COption_MonitorEventZDecodeErrorZ;
395 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
396 class CResult_DescriptionCreationErrorZ;
397 class CResult_RoutingFeesDecodeErrorZ;
398 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
399 class CResult_PaymentRelayDecodeErrorZ;
400 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
401 class CResult_QueryShortChannelIdsDecodeErrorZ;
402 class CResult_VerifiedInvoiceRequestNoneZ;
403 class CResult_UpdateAddHTLCDecodeErrorZ;
404 class COption_MonitorEventZ;
406 class CResult_COption_TypeZDecodeErrorZ;
407 class CResult_COption_PathFailureZDecodeErrorZ;
408 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
409 class CResult_UpdateFailHTLCDecodeErrorZ;
410 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
411 class CResult_RevokeAndACKDecodeErrorZ;
412 class CResult_SpendableOutputDescriptorDecodeErrorZ;
413 class C2Tuple_PublicKeyCOption_SocketAddressZZ;
414 class CResult_UnsignedChannelUpdateDecodeErrorZ;
415 class CResult_PayeePubKeySecp256k1ErrorZ;
416 class COption_BigEndianScalarZ;
417 class CResult_PublicKeySecp256k1ErrorZ;
418 class CResult_CVec_ECDSASignatureZNoneZ;
419 class CVec_BlindedHopZ;
420 class CResult_COption_ClosureReasonZDecodeErrorZ;
421 class CResult_InvoiceErrorDecodeErrorZ;
422 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
423 class CResult_RouteParametersDecodeErrorZ;
424 class CResult_PrivateRouteCreationErrorZ;
425 class CResult_NodeAliasDecodeErrorZ;
426 class CVec_UpdateFulfillHTLCZ;
427 class CVec_C2Tuple_u32CVec_u8ZZZ;
428 class CResult_AnnouncementSignaturesDecodeErrorZ;
429 class CResult_UpdateFulfillHTLCDecodeErrorZ;
430 class CResult_TxCompleteDecodeErrorZ;
431 class CResult_StrSecp256k1ErrorZ;
432 class CResult_NodeFeaturesDecodeErrorZ;
433 class CResult_InMemorySignerDecodeErrorZ;
434 class CResult_TxSignaturesDecodeErrorZ;
435 class CVec_HTLCDescriptorZ;
436 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
437 class COption_PathFailureZ;
438 class CVec_ECDSASignatureZ;
439 class CResult_ChannelUpdateInfoDecodeErrorZ;
440 class CVec_UpdateFailHTLCZ;
442 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
443 class CVec_SpendableOutputDescriptorZ;
444 class C2Tuple_OutPointCVec_u8ZZ;
445 class COption_C2Tuple_u64u64ZZ;
446 class CResult_ChannelAnnouncementDecodeErrorZ;
447 class CResult_HTLCUpdateDecodeErrorZ;
448 class CResult_TxAddInputDecodeErrorZ;
449 class CVec_OutPointZ;
450 class CResult_TxInitRbfDecodeErrorZ;
451 class COption_WriteableScoreZ;
453 class CResult_PositiveTimestampCreationErrorZ;
454 class CResult_ChannelMonitorUpdateDecodeErrorZ;
455 class C2Tuple_BlindedPayInfoBlindedPathZ;
456 class CResult_ReplyChannelRangeDecodeErrorZ;
457 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
458 class CResult_TrustedClosingTransactionNoneZ;
459 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
460 class C2Tuple_PublicKeyTypeZ;
461 class CResult_TxRemoveOutputDecodeErrorZ;
462 class CResult_ChannelReestablishDecodeErrorZ;
463 class CResult_OnionMessageDecodeErrorZ;
464 class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ;
465 class CResult_C2Tuple_CVec_u8ZusizeZNoneZ;
466 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
467 class CResult_InitFeaturesDecodeErrorZ;
468 class CResult_PublicKeyNoneZ;
469 class CResult_PingDecodeErrorZ;
470 class CResult_BlindedHopFeaturesDecodeErrorZ;
471 class CVec_TransactionOutputsZ;
472 class COption_HTLCClaimZ;
474 class CVec_CVec_u8ZZ;
475 class CResult_ProbabilisticScorerDecodeErrorZ;
476 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
477 class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ;
478 class CResult_ShutdownScriptDecodeErrorZ;
479 class C2Tuple_usizeTransactionZ;
480 class CResult_NodeAnnouncementDecodeErrorZ;
482 class CVec_ChannelMonitorZ;
483 class CResult_AcceptChannelV2DecodeErrorZ;
484 class CResult_TxCreationKeysDecodeErrorZ;
485 class CResult_RouteHopDecodeErrorZ;
486 class CVec_HTLCOutputInCommitmentZ;
487 class CResult_CoinSelectionNoneZ;
488 class C2Tuple_ThirtyTwoBytesPublicKeyZ;
489 class CResult_SiPrefixBolt11ParseErrorZ;
490 class CResult_BlindedPathDecodeErrorZ;
492 class CResult_NoneIOErrorZ;
493 class CResult_MaxDustHTLCExposureDecodeErrorZ;
494 class CVec_CommitmentTransactionZ;
495 class CResult_FundingSignedDecodeErrorZ;
496 class CResult_RecoverableSignatureNoneZ;
497 class CResult_SocketAddressDecodeErrorZ;
499 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
501 class CResult_NetworkGraphDecodeErrorZ;
502 class CResult_NodeInfoDecodeErrorZ;
505 class CResult_RouteLightningErrorZ;
506 class CResult_NonePaymentSendFailureZ;
507 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
508 class CResult_ChannelPublicKeysDecodeErrorZ;
509 class CVec_ClaimedHTLCZ;
510 class COption_CVec_ThirtyTwoBytesZZ;
511 class CVec_SocketAddressZ;
512 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
513 class CResult_HolderCommitmentTransactionDecodeErrorZ;
514 class CResult_WarningMessageDecodeErrorZ;
515 class CResult_ChannelCounterpartyDecodeErrorZ;
516 class CResult_InitDecodeErrorZ;
517 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
518 class CResult_ClaimedHTLCDecodeErrorZ;
519 class CResult_PaymentPurposeDecodeErrorZ;
520 class CVec_MonitorUpdateIdZ;
521 class CResult_OutPointDecodeErrorZ;
522 class CVec_ChannelDetailsZ;
523 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
524 class CVec_MessageSendEventZ;
525 class CResult_RouteHintHopDecodeErrorZ;
526 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
527 class CResult_BlindedPayInfoDecodeErrorZ;
528 class CResult_ThirtyTwoBytesAPIErrorZ;
529 class COption_ChannelShutdownStateZ;
530 class CResult_CVec_CVec_u8ZZNoneZ;
531 class CResult_AcceptChannelDecodeErrorZ;
532 class CResult_HostnameDecodeErrorZ;
533 class C2Tuple_u64u16Z;
534 class COption_ThirtyTwoBytesZ;
536 class COption_SecretKeyZ;
537 class CResult_ThirtyTwoBytesPaymentErrorZ;
538 class COption_EventZ;
539 class CResult_ChannelTypeFeaturesDecodeErrorZ;
540 class COption_CVec_SocketAddressZZ;
541 class CVec_RouteHintZ;
543 class COption_PaymentFailureReasonZ;
544 class CResult_ECDSASignatureNoneZ;
546 class CResult_BlindedTailDecodeErrorZ;
547 class CResult_SocketAddressSocketAddressParseErrorZ;
548 class COption_C2Tuple_u64u16ZZ;
549 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
550 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
551 class CResult_ChannelDerivationParametersDecodeErrorZ;
552 class CResult_PaymentConstraintsDecodeErrorZ;
553 class C2Tuple_u32CVec_u8ZZ;
554 class CVec_C2Tuple_PublicKeyTypeZZ;
555 class CResult_OnionMessagePathNoneZ;
556 class CResult_RefundBolt12ParseErrorZ;
557 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
558 class CVec_C2Tuple_u64CVec_u8ZZZ;
559 class CResult_u32GraphSyncErrorZ;
560 class CVec_PhantomRouteHintsZ;
561 class CResult_NoneAPIErrorZ;
562 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
564 class CResult_ChannelDetailsDecodeErrorZ;
565 class CVec_PublicKeyZ;
566 class CVec_C2Tuple_usizeTransactionZZ;
567 class CResult_TxRemoveInputDecodeErrorZ;
568 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
569 class CResult_OffersMessageDecodeErrorZ;
570 class C2Tuple_u64u64Z;
571 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
572 class CResult_RecipientOnionFieldsDecodeErrorZ;
573 class C2Tuple_u32TxOutZ;
575 class CResult_ChannelConfigDecodeErrorZ;
576 class CVec_PrivateRouteZ;
578 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
579 class CResult_ShutdownDecodeErrorZ;
580 class C2Tuple_u64CVec_u8ZZ;
581 class CResult_OfferBolt12ParseErrorZ;
582 class CResult_ThirtyTwoBytesRetryableSendFailureZ;
583 class CVec_MonitorEventZ;
584 class CResult_BigSizeDecodeErrorZ;
585 class CResult_TxOutUtxoLookupErrorZ;
586 class CResult_BlindedPathNoneZ;
587 class COption_usizeZ;
588 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
589 class CResult_NoneNoneZ;
590 class CResult_boolPeerHandleErrorZ;
591 class CResult_ChannelUpdateDecodeErrorZ;
592 class CVec_APIErrorZ;
593 class COption_TxOutZ;
594 class COption_ClosureReasonZ;
595 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
596 class CResult_TransactionU16LenLimitedDecodeErrorZ;
597 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
598 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
599 class CResult_OpenChannelV2DecodeErrorZ;
600 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
601 class C2Tuple_PublicKeyOnionMessageZ;
602 class CResult_RouteDecodeErrorZ;
603 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
605 class CResult_TxAddOutputDecodeErrorZ;
606 class COption_CVec_u8ZZ;
612 Str(const Str&) = delete;
613 Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
614 Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
615 operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
616 ~Str() { Str_free(self); }
617 Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
618 LDKStr* operator &() { return &self; }
619 LDKStr* operator ->() { return &self; }
620 const LDKStr* operator &() const { return &self; }
621 const LDKStr* operator ->() const { return &self; }
627 Refund(const Refund&) = delete;
628 Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
629 Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
630 operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
631 ~Refund() { Refund_free(self); }
632 Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
633 LDKRefund* operator &() { return &self; }
634 LDKRefund* operator ->() { return &self; }
635 const LDKRefund* operator &() const { return &self; }
636 const LDKRefund* operator ->() const { return &self; }
642 Retry(const Retry&) = delete;
643 Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
644 Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
645 operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
646 ~Retry() { Retry_free(self); }
647 Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
648 LDKRetry* operator &() { return &self; }
649 LDKRetry* operator ->() { return &self; }
650 const LDKRetry* operator &() const { return &self; }
651 const LDKRetry* operator ->() const { return &self; }
653 class RetryableSendFailure {
655 LDKRetryableSendFailure self;
657 RetryableSendFailure(const RetryableSendFailure&) = delete;
658 RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
659 RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
660 operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
661 RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
662 LDKRetryableSendFailure* operator &() { return &self; }
663 LDKRetryableSendFailure* operator ->() { return &self; }
664 const LDKRetryableSendFailure* operator &() const { return &self; }
665 const LDKRetryableSendFailure* operator ->() const { return &self; }
667 class PaymentSendFailure {
669 LDKPaymentSendFailure self;
671 PaymentSendFailure(const PaymentSendFailure&) = delete;
672 PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
673 PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
674 operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
675 ~PaymentSendFailure() { PaymentSendFailure_free(self); }
676 PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
677 LDKPaymentSendFailure* operator &() { return &self; }
678 LDKPaymentSendFailure* operator ->() { return &self; }
679 const LDKPaymentSendFailure* operator &() const { return &self; }
680 const LDKPaymentSendFailure* operator ->() const { return &self; }
682 class ProbeSendFailure {
684 LDKProbeSendFailure self;
686 ProbeSendFailure(const ProbeSendFailure&) = delete;
687 ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
688 ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
689 operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
690 ~ProbeSendFailure() { ProbeSendFailure_free(self); }
691 ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
692 LDKProbeSendFailure* operator &() { return &self; }
693 LDKProbeSendFailure* operator ->() { return &self; }
694 const LDKProbeSendFailure* operator &() const { return &self; }
695 const LDKProbeSendFailure* operator ->() const { return &self; }
697 class RecipientOnionFields {
699 LDKRecipientOnionFields self;
701 RecipientOnionFields(const RecipientOnionFields&) = delete;
702 RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
703 RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
704 operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
705 ~RecipientOnionFields() { RecipientOnionFields_free(self); }
706 RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
707 LDKRecipientOnionFields* operator &() { return &self; }
708 LDKRecipientOnionFields* operator ->() { return &self; }
709 const LDKRecipientOnionFields* operator &() const { return &self; }
710 const LDKRecipientOnionFields* operator ->() const { return &self; }
712 class UnsignedBolt12Invoice {
714 LDKUnsignedBolt12Invoice self;
716 UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
717 UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
718 UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
719 operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
720 ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
721 UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
722 LDKUnsignedBolt12Invoice* operator &() { return &self; }
723 LDKUnsignedBolt12Invoice* operator ->() { return &self; }
724 const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
725 const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
727 class Bolt12Invoice {
729 LDKBolt12Invoice self;
731 Bolt12Invoice(const Bolt12Invoice&) = delete;
732 Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
733 Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
734 operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
735 ~Bolt12Invoice() { Bolt12Invoice_free(self); }
736 Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
737 LDKBolt12Invoice* operator &() { return &self; }
738 LDKBolt12Invoice* operator ->() { return &self; }
739 const LDKBolt12Invoice* operator &() const { return &self; }
740 const LDKBolt12Invoice* operator ->() const { return &self; }
742 class BlindedPayInfo {
744 LDKBlindedPayInfo self;
746 BlindedPayInfo(const BlindedPayInfo&) = delete;
747 BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
748 BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
749 operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
750 ~BlindedPayInfo() { BlindedPayInfo_free(self); }
751 BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
752 LDKBlindedPayInfo* operator &() { return &self; }
753 LDKBlindedPayInfo* operator ->() { return &self; }
754 const LDKBlindedPayInfo* operator &() const { return &self; }
755 const LDKBlindedPayInfo* operator ->() const { return &self; }
757 class DelayedPaymentOutputDescriptor {
759 LDKDelayedPaymentOutputDescriptor self;
761 DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
762 DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
763 DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
764 operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
765 ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
766 DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
767 LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
768 LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
769 const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
770 const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
772 class StaticPaymentOutputDescriptor {
774 LDKStaticPaymentOutputDescriptor self;
776 StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
777 StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
778 StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
779 operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
780 ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
781 StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
782 LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
783 LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
784 const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
785 const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
787 class SpendableOutputDescriptor {
789 LDKSpendableOutputDescriptor self;
791 SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
792 SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
793 SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
794 operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
795 ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
796 SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
797 LDKSpendableOutputDescriptor* operator &() { return &self; }
798 LDKSpendableOutputDescriptor* operator ->() { return &self; }
799 const LDKSpendableOutputDescriptor* operator &() const { return &self; }
800 const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
802 class ChannelSigner {
804 LDKChannelSigner self;
806 ChannelSigner(const ChannelSigner&) = delete;
807 ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
808 ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
809 operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
810 ~ChannelSigner() { ChannelSigner_free(self); }
811 ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
812 LDKChannelSigner* operator &() { return &self; }
813 LDKChannelSigner* operator ->() { return &self; }
814 const LDKChannelSigner* operator &() const { return &self; }
815 const LDKChannelSigner* operator ->() const { return &self; }
817 * Gets the per-commitment point for a specific commitment number
819 * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
821 inline LDKPublicKey get_per_commitment_point(uint64_t idx);
823 * Gets the commitment secret for a specific commitment number as part of the revocation process
825 * An external signer implementation should error here if the commitment was already signed
826 * and should refuse to sign it in the future.
828 * May be called more than once for the same index.
830 * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
832 inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
834 * Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
836 * This is required in order for the signer to make sure that releasing a commitment
837 * secret won't leave us without a broadcastable holder transaction.
838 * Policy checks should be implemented in this function, including checking the amount
839 * sent to us and checking the HTLCs.
841 * The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
842 * A validating signer should ensure that an HTLC output is removed only when the matching
843 * preimage is provided, or when the value to holder is restored.
845 * Note that all the relevant preimages will be provided, but there may also be additional
846 * irrelevant or duplicate preimages.
848 inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
850 * Returns an arbitrary identifier describing the set of keys which are provided back to you in
851 * some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
852 * [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
854 inline LDKThirtyTwoBytes channel_keys_id();
856 * Set the counterparty static channel data, including basepoints,
857 * `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
859 * This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
860 * instance, LDK will call this method exactly once - either immediately after construction
861 * (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
862 * information has been generated.
864 * channel_parameters.is_populated() MUST be true.
866 inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
868 class EcdsaChannelSigner {
870 LDKEcdsaChannelSigner self;
872 EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
873 EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
874 EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
875 operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
876 ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
877 EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
878 LDKEcdsaChannelSigner* operator &() { return &self; }
879 LDKEcdsaChannelSigner* operator ->() { return &self; }
880 const LDKEcdsaChannelSigner* operator &() const { return &self; }
881 const LDKEcdsaChannelSigner* operator ->() const { return &self; }
883 * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
885 * Note that if signing fails or is rejected, the channel will be force-closed.
887 * Policy checks should be implemented in this function, including checking the amount
888 * sent to us and checking the HTLCs.
890 * The preimages of outgoing HTLCs that were fulfilled since the last commitment are provided.
891 * A validating signer should ensure that an HTLC output is removed only when the matching
892 * preimage is provided, or when the value to holder is restored.
894 * Note that all the relevant preimages will be provided, but there may also be additional
895 * irrelevant or duplicate preimages.
897 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages);
899 * Validate the counterparty's revocation.
901 * This is required in order for the signer to make sure that the state has moved
902 * forward and it is safe to sign the next counterparty commitment.
904 inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
906 * Creates a signature for a holder's commitment transaction and its claiming HTLC transactions.
908 * This will be called
909 * - with a non-revoked `commitment_tx`.
910 * - with the latest `commitment_tx` when we initiate a force-close.
911 * - with the previous `commitment_tx`, just to get claiming HTLC
912 * signatures, if we are reacting to a [`ChannelMonitor`]
913 * [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
914 * that decided to broadcast before it had been updated to the latest `commitment_tx`.
916 * This may be called multiple times for the same transaction.
918 * An external signer implementation should check that the commitment has not been revoked.
920 * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
922 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
924 * Create a signature for the given input in a transaction spending an HTLC transaction output
925 * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
927 * A justice transaction may claim multiple outputs at the same time if timelocks are
928 * similar, but only a signature for the input at index `input` should be signed for here.
929 * It may be called multiple times for same output(s) if a fee-bump is needed with regards
930 * to an upcoming timelock expiration.
932 * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
934 * `per_commitment_key` is revocation secret which was provided by our counterparty when they
935 * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
936 * not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
939 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]);
941 * Create a signature for the given input in a transaction spending a commitment transaction
942 * HTLC output when our counterparty broadcasts an old state.
944 * A justice transaction may claim multiple outputs at the same time if timelocks are
945 * similar, but only a signature for the input at index `input` should be signed for here.
946 * It may be called multiple times for same output(s) if a fee-bump is needed with regards
947 * to an upcoming timelock expiration.
949 * `amount` is the value of the output spent by this input, committed to in the BIP 143
952 * `per_commitment_key` is revocation secret which was provided by our counterparty when they
953 * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
954 * not allow the spending of any funds by itself (you need our holder revocation_secret to do
957 * `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
958 * (which is committed to in the BIP 143 signatures).
960 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);
962 * Computes the signature for a commitment transaction's HTLC output used as an input within
963 * `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
964 * must be be computed using [`EcdsaSighashType::All`]. Note that this should only be used to
965 * sign HTLC transactions from channels supporting anchor outputs after all additional
966 * inputs/outputs have been added to the transaction.
968 * [`EcdsaSighashType::All`]: bitcoin::blockdata::transaction::EcdsaSighashType::All
970 inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
972 * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
973 * transaction, either offered or received.
975 * Such a transaction may claim multiples offered outputs at same time if we know the
976 * preimage for each when we create it, but only the input at index `input` should be
977 * signed for here. It may be called multiple times for same output(s) if a fee-bump is
978 * needed with regards to an upcoming timelock expiration.
980 * `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
983 * `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
985 * `per_commitment_point` is the dynamic point corresponding to the channel state
986 * detected onchain. It has been generated by our counterparty and is used to derive
987 * channel state keys, which are then included in the witness script and committed to in the
990 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);
992 * Create a signature for a (proposed) closing transaction.
994 * Note that, due to rounding, there may be one "missing" satoshi, and either party may have
995 * chosen to forgo their output as dust.
997 inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
999 * Computes the signature for a commitment transaction's anchor output used as an
1000 * input within `anchor_tx`, which spends the commitment transaction, at index `input`.
1002 inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
1004 * Signs a channel announcement message with our funding key proving it comes from one of the
1005 * channel participants.
1007 * Channel announcements also require a signature from each node's network key. Our node
1008 * signature is computed through [`NodeSigner::sign_gossip_message`].
1010 * Note that if this fails or is rejected, the channel will not be publicly announced and
1011 * our counterparty may (though likely will not) close the channel on us for violating the
1014 inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
1016 class WriteableEcdsaChannelSigner {
1018 LDKWriteableEcdsaChannelSigner self;
1020 WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
1021 WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
1022 WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
1023 operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
1024 ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
1025 WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
1026 LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
1027 LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
1028 const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
1029 const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
1035 Recipient(const Recipient&) = delete;
1036 Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
1037 Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
1038 operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
1039 Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
1040 LDKRecipient* operator &() { return &self; }
1041 LDKRecipient* operator ->() { return &self; }
1042 const LDKRecipient* operator &() const { return &self; }
1043 const LDKRecipient* operator ->() const { return &self; }
1045 class EntropySource {
1047 LDKEntropySource self;
1049 EntropySource(const EntropySource&) = delete;
1050 EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
1051 EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
1052 operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
1053 ~EntropySource() { EntropySource_free(self); }
1054 EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
1055 LDKEntropySource* operator &() { return &self; }
1056 LDKEntropySource* operator ->() { return &self; }
1057 const LDKEntropySource* operator &() const { return &self; }
1058 const LDKEntropySource* operator ->() const { return &self; }
1060 * Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
1061 * different value each time it is called.
1063 inline LDKThirtyTwoBytes get_secure_random_bytes();
1069 NodeSigner(const NodeSigner&) = delete;
1070 NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
1071 NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
1072 operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
1073 ~NodeSigner() { NodeSigner_free(self); }
1074 NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
1075 LDKNodeSigner* operator &() { return &self; }
1076 LDKNodeSigner* operator ->() { return &self; }
1077 const LDKNodeSigner* operator &() const { return &self; }
1078 const LDKNodeSigner* operator ->() const { return &self; }
1080 * Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1082 * If the implementor of this trait supports [phantom node payments], then every node that is
1083 * intended to be included in the phantom invoice route hints must return the same value from
1086 * This method must return the same value each time it is called.
1088 * [phantom node payments]: PhantomKeysManager
1090 inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1092 * Get node id based on the provided [`Recipient`].
1094 * This method must return the same value each time it is called with a given [`Recipient`]
1097 * Errors if the [`Recipient`] variant is not supported by the implementation.
1099 inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
1101 * Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
1102 * one is provided. Note that this tweak can be applied to `other_key` instead of our node
1103 * secret, though this is less efficient.
1105 * Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
1106 * should be resolved to allow LDK to resume forwarding HTLCs.
1108 * Errors if the [`Recipient`] variant is not supported by the implementation.
1110 inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
1114 * By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1115 * this trait to parse the invoice and make sure they're signing what they expect, rather than
1116 * blindly signing the hash.
1118 * The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
1120 * The secret key used to sign the invoice is dependent on the [`Recipient`].
1122 * Errors if the [`Recipient`] variant is not supported by the implementation.
1124 inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
1126 * Signs the [`TaggedHash`] of a BOLT 12 invoice request.
1128 * May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
1129 * `invoice_request` is the callee.
1131 * Implementors may check that the `invoice_request` is expected rather than blindly signing
1132 * the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
1133 * the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
1134 * [`UnsignedInvoiceRequest::payer_id`].
1136 * [`TaggedHash`]: crate::offers::merkle::TaggedHash
1138 inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
1140 * Signs the [`TaggedHash`] of a BOLT 12 invoice.
1142 * May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
1145 * Implementors may check that the `invoice` is expected rather than blindly signing the tagged
1146 * hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
1147 * key or an ephemeral key to preserve privacy, whichever is associated with
1148 * [`UnsignedBolt12Invoice::signing_pubkey`].
1150 * [`TaggedHash`]: crate::offers::merkle::TaggedHash
1152 inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
1154 * Sign a gossip message.
1156 * Note that if this fails, LDK may panic and the message will not be broadcast to the network
1157 * or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
1158 * message to be broadcast, as otherwise it may prevent one from receiving funds over the
1159 * corresponding channel.
1161 inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
1163 class SignerProvider {
1165 LDKSignerProvider self;
1167 SignerProvider(const SignerProvider&) = delete;
1168 SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
1169 SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
1170 operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
1171 ~SignerProvider() { SignerProvider_free(self); }
1172 SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
1173 LDKSignerProvider* operator &() { return &self; }
1174 LDKSignerProvider* operator ->() { return &self; }
1175 const LDKSignerProvider* operator &() const { return &self; }
1176 const LDKSignerProvider* operator ->() const { return &self; }
1178 * Generates a unique `channel_keys_id` that can be used to obtain a [`Self::Signer`] through
1179 * [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
1180 * implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
1181 * `channel_keys_id`.
1183 * This method must return a different value each time it is called.
1185 inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
1187 * Derives the private key material backing a `Signer`.
1189 * To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
1190 * [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
1191 * re-derived from its `channel_keys_id`, which can be obtained through its trait method
1192 * [`ChannelSigner::channel_keys_id`].
1194 inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
1196 * Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
1197 * This is only called during deserialization of other objects which contain
1198 * [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
1199 * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1200 * contain no versioning scheme. You may wish to include your own version prefix and ensure
1201 * you've read all of the provided bytes to ensure no corruption occurred.
1203 * This method is slowly being phased out -- it will only be called when reading objects
1204 * written by LDK versions prior to 0.0.113.
1206 * [`Signer`]: Self::Signer
1207 * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1208 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1210 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1212 * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1214 * If this function returns an error, this will result in a channel failing to open.
1216 * This method should return a different value each time it is called, to avoid linking
1217 * on-chain funds across channels as controlled to the same user.
1219 inline LDK::CResult_CVec_u8ZNoneZ get_destination_script();
1221 * Get a script pubkey which we will send funds to when closing a channel.
1223 * If this function returns an error, this will result in a channel failing to open or close.
1224 * In the event of a failure when the counterparty is initiating a close, this can result in a
1225 * channel force close.
1227 * This method should return a different value each time it is called, to avoid linking
1228 * on-chain funds across channels as controlled to the same user.
1230 inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
1232 class InMemorySigner {
1234 LDKInMemorySigner self;
1236 InMemorySigner(const InMemorySigner&) = delete;
1237 InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1238 InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1239 operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1240 ~InMemorySigner() { InMemorySigner_free(self); }
1241 InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1242 LDKInMemorySigner* operator &() { return &self; }
1243 LDKInMemorySigner* operator ->() { return &self; }
1244 const LDKInMemorySigner* operator &() const { return &self; }
1245 const LDKInMemorySigner* operator ->() const { return &self; }
1249 LDKKeysManager self;
1251 KeysManager(const KeysManager&) = delete;
1252 KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1253 KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1254 operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1255 ~KeysManager() { KeysManager_free(self); }
1256 KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1257 LDKKeysManager* operator &() { return &self; }
1258 LDKKeysManager* operator ->() { return &self; }
1259 const LDKKeysManager* operator &() const { return &self; }
1260 const LDKKeysManager* operator ->() const { return &self; }
1262 class PhantomKeysManager {
1264 LDKPhantomKeysManager self;
1266 PhantomKeysManager(const PhantomKeysManager&) = delete;
1267 PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1268 PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1269 operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1270 ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1271 PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1272 LDKPhantomKeysManager* operator &() { return &self; }
1273 LDKPhantomKeysManager* operator ->() { return &self; }
1274 const LDKPhantomKeysManager* operator &() const { return &self; }
1275 const LDKPhantomKeysManager* operator ->() const { return &self; }
1277 class BackgroundProcessor {
1279 LDKBackgroundProcessor self;
1281 BackgroundProcessor(const BackgroundProcessor&) = delete;
1282 BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
1283 BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
1284 operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
1285 ~BackgroundProcessor() { BackgroundProcessor_free(self); }
1286 BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
1287 LDKBackgroundProcessor* operator &() { return &self; }
1288 LDKBackgroundProcessor* operator ->() { return &self; }
1289 const LDKBackgroundProcessor* operator &() const { return &self; }
1290 const LDKBackgroundProcessor* operator ->() const { return &self; }
1296 GossipSync(const GossipSync&) = delete;
1297 GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
1298 GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
1299 operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
1300 ~GossipSync() { GossipSync_free(self); }
1301 GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
1302 LDKGossipSync* operator &() { return &self; }
1303 LDKGossipSync* operator ->() { return &self; }
1304 const LDKGossipSync* operator &() const { return &self; }
1305 const LDKGossipSync* operator ->() const { return &self; }
1307 class DefaultRouter {
1309 LDKDefaultRouter self;
1311 DefaultRouter(const DefaultRouter&) = delete;
1312 DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
1313 DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
1314 operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
1315 ~DefaultRouter() { DefaultRouter_free(self); }
1316 DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
1317 LDKDefaultRouter* operator &() { return &self; }
1318 LDKDefaultRouter* operator ->() { return &self; }
1319 const LDKDefaultRouter* operator &() const { return &self; }
1320 const LDKDefaultRouter* operator ->() const { return &self; }
1326 Router(const Router&) = delete;
1327 Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
1328 Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
1329 operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
1330 ~Router() { Router_free(self); }
1331 Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
1332 LDKRouter* operator &() { return &self; }
1333 LDKRouter* operator ->() { return &self; }
1334 const LDKRouter* operator &() const { return &self; }
1335 const LDKRouter* operator ->() const { return &self; }
1337 * Finds a [`Route`] for a payment between the given `payer` and a payee.
1339 * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1340 * and [`RouteParameters::final_value_msat`], respectively.
1342 * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1344 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);
1346 * Finds a [`Route`] for a payment between the given `payer` and a payee.
1348 * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1349 * and [`RouteParameters::final_value_msat`], respectively.
1351 * Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
1354 * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1356 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);
1358 class ScorerAccountingForInFlightHtlcs {
1360 LDKScorerAccountingForInFlightHtlcs self;
1362 ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
1363 ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
1364 ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
1365 operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
1366 ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
1367 ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
1368 LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
1369 LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
1370 const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
1371 const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
1373 class InFlightHtlcs {
1375 LDKInFlightHtlcs self;
1377 InFlightHtlcs(const InFlightHtlcs&) = delete;
1378 InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
1379 InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
1380 operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
1381 ~InFlightHtlcs() { InFlightHtlcs_free(self); }
1382 InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
1383 LDKInFlightHtlcs* operator &() { return &self; }
1384 LDKInFlightHtlcs* operator ->() { return &self; }
1385 const LDKInFlightHtlcs* operator &() const { return &self; }
1386 const LDKInFlightHtlcs* operator ->() const { return &self; }
1392 RouteHop(const RouteHop&) = delete;
1393 RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1394 RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1395 operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1396 ~RouteHop() { RouteHop_free(self); }
1397 RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1398 LDKRouteHop* operator &() { return &self; }
1399 LDKRouteHop* operator ->() { return &self; }
1400 const LDKRouteHop* operator &() const { return &self; }
1401 const LDKRouteHop* operator ->() const { return &self; }
1405 LDKBlindedTail self;
1407 BlindedTail(const BlindedTail&) = delete;
1408 BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
1409 BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
1410 operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
1411 ~BlindedTail() { BlindedTail_free(self); }
1412 BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
1413 LDKBlindedTail* operator &() { return &self; }
1414 LDKBlindedTail* operator ->() { return &self; }
1415 const LDKBlindedTail* operator &() const { return &self; }
1416 const LDKBlindedTail* operator ->() const { return &self; }
1422 Path(const Path&) = delete;
1423 Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
1424 Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
1425 operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
1426 ~Path() { Path_free(self); }
1427 Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
1428 LDKPath* operator &() { return &self; }
1429 LDKPath* operator ->() { return &self; }
1430 const LDKPath* operator &() const { return &self; }
1431 const LDKPath* operator ->() const { return &self; }
1437 Route(const Route&) = delete;
1438 Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1439 Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1440 operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1441 ~Route() { Route_free(self); }
1442 Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1443 LDKRoute* operator &() { return &self; }
1444 LDKRoute* operator ->() { return &self; }
1445 const LDKRoute* operator &() const { return &self; }
1446 const LDKRoute* operator ->() const { return &self; }
1448 class RouteParameters {
1450 LDKRouteParameters self;
1452 RouteParameters(const RouteParameters&) = delete;
1453 RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
1454 RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
1455 operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
1456 ~RouteParameters() { RouteParameters_free(self); }
1457 RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
1458 LDKRouteParameters* operator &() { return &self; }
1459 LDKRouteParameters* operator ->() { return &self; }
1460 const LDKRouteParameters* operator &() const { return &self; }
1461 const LDKRouteParameters* operator ->() const { return &self; }
1463 class PaymentParameters {
1465 LDKPaymentParameters self;
1467 PaymentParameters(const PaymentParameters&) = delete;
1468 PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
1469 PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
1470 operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
1471 ~PaymentParameters() { PaymentParameters_free(self); }
1472 PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
1473 LDKPaymentParameters* operator &() { return &self; }
1474 LDKPaymentParameters* operator ->() { return &self; }
1475 const LDKPaymentParameters* operator &() const { return &self; }
1476 const LDKPaymentParameters* operator ->() const { return &self; }
1482 Payee(const Payee&) = delete;
1483 Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
1484 Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
1485 operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
1486 ~Payee() { Payee_free(self); }
1487 Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
1488 LDKPayee* operator &() { return &self; }
1489 LDKPayee* operator ->() { return &self; }
1490 const LDKPayee* operator &() const { return &self; }
1491 const LDKPayee* operator ->() const { return &self; }
1497 RouteHint(const RouteHint&) = delete;
1498 RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1499 RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1500 operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1501 ~RouteHint() { RouteHint_free(self); }
1502 RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1503 LDKRouteHint* operator &() { return &self; }
1504 LDKRouteHint* operator ->() { return &self; }
1505 const LDKRouteHint* operator &() const { return &self; }
1506 const LDKRouteHint* operator ->() const { return &self; }
1508 class RouteHintHop {
1510 LDKRouteHintHop self;
1512 RouteHintHop(const RouteHintHop&) = delete;
1513 RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
1514 RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
1515 operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
1516 ~RouteHintHop() { RouteHintHop_free(self); }
1517 RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
1518 LDKRouteHintHop* operator &() { return &self; }
1519 LDKRouteHintHop* operator ->() { return &self; }
1520 const LDKRouteHintHop* operator &() const { return &self; }
1521 const LDKRouteHintHop* operator ->() const { return &self; }
1525 LDKScoreLookUp self;
1527 ScoreLookUp(const ScoreLookUp&) = delete;
1528 ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
1529 ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
1530 operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
1531 ~ScoreLookUp() { ScoreLookUp_free(self); }
1532 ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
1533 LDKScoreLookUp* operator &() { return &self; }
1534 LDKScoreLookUp* operator ->() { return &self; }
1535 const LDKScoreLookUp* operator &() const { return &self; }
1536 const LDKScoreLookUp* operator ->() const { return &self; }
1538 * Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1539 * given channel in the direction from `source` to `target`.
1541 * The channel's capacity (less any other MPP parts that are also being considered for use in
1542 * the same payment) is given by `capacity_msat`. It may be determined from various sources
1543 * such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1544 * [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1545 * Thus, implementations should be overflow-safe.
1547 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, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
1551 LDKScoreUpdate self;
1553 ScoreUpdate(const ScoreUpdate&) = delete;
1554 ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
1555 ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
1556 operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
1557 ~ScoreUpdate() { ScoreUpdate_free(self); }
1558 ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
1559 LDKScoreUpdate* operator &() { return &self; }
1560 LDKScoreUpdate* operator ->() { return &self; }
1561 const LDKScoreUpdate* operator &() const { return &self; }
1562 const LDKScoreUpdate* operator ->() const { return &self; }
1564 * Handles updating channel penalties after failing to route through a channel.
1566 inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
1568 * Handles updating channel penalties after successfully routing along a path.
1570 inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path);
1572 * Handles updating channel penalties after a probe over the given path failed.
1574 inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id);
1576 * Handles updating channel penalties after a probe over the given path succeeded.
1578 inline void probe_successful(const struct LDKPath *NONNULL_PTR path);
1584 Score(const Score&) = delete;
1585 Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1586 Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1587 operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1588 ~Score() { Score_free(self); }
1589 Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1590 LDKScore* operator &() { return &self; }
1591 LDKScore* operator ->() { return &self; }
1592 const LDKScore* operator &() const { return &self; }
1593 const LDKScore* operator ->() const { return &self; }
1595 class LockableScore {
1597 LDKLockableScore self;
1599 LockableScore(const LockableScore&) = delete;
1600 LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1601 LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1602 operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1603 ~LockableScore() { LockableScore_free(self); }
1604 LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1605 LDKLockableScore* operator &() { return &self; }
1606 LDKLockableScore* operator ->() { return &self; }
1607 const LDKLockableScore* operator &() const { return &self; }
1608 const LDKLockableScore* operator ->() const { return &self; }
1610 * Returns read locked scorer.
1612 inline LDK::ScoreLookUp read_lock();
1614 * Returns write locked scorer.
1616 inline LDK::ScoreUpdate write_lock();
1618 class WriteableScore {
1620 LDKWriteableScore self;
1622 WriteableScore(const WriteableScore&) = delete;
1623 WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
1624 WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
1625 operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
1626 ~WriteableScore() { WriteableScore_free(self); }
1627 WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
1628 LDKWriteableScore* operator &() { return &self; }
1629 LDKWriteableScore* operator ->() { return &self; }
1630 const LDKWriteableScore* operator &() const { return &self; }
1631 const LDKWriteableScore* operator ->() const { return &self; }
1633 class MultiThreadedLockableScore {
1635 LDKMultiThreadedLockableScore self;
1637 MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1638 MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1639 MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1640 operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1641 ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1642 MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1643 LDKMultiThreadedLockableScore* operator &() { return &self; }
1644 LDKMultiThreadedLockableScore* operator ->() { return &self; }
1645 const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1646 const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1648 class MultiThreadedScoreLockRead {
1650 LDKMultiThreadedScoreLockRead self;
1652 MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
1653 MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
1654 MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
1655 operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
1656 ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
1657 MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
1658 LDKMultiThreadedScoreLockRead* operator &() { return &self; }
1659 LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
1660 const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
1661 const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
1663 class MultiThreadedScoreLockWrite {
1665 LDKMultiThreadedScoreLockWrite self;
1667 MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
1668 MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
1669 MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
1670 operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
1671 ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
1672 MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
1673 LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
1674 LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
1675 const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
1676 const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
1678 class ChannelUsage {
1680 LDKChannelUsage self;
1682 ChannelUsage(const ChannelUsage&) = delete;
1683 ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
1684 ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
1685 operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
1686 ~ChannelUsage() { ChannelUsage_free(self); }
1687 ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
1688 LDKChannelUsage* operator &() { return &self; }
1689 LDKChannelUsage* operator ->() { return &self; }
1690 const LDKChannelUsage* operator &() const { return &self; }
1691 const LDKChannelUsage* operator ->() const { return &self; }
1693 class FixedPenaltyScorer {
1695 LDKFixedPenaltyScorer self;
1697 FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1698 FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1699 FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1700 operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1701 ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1702 FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1703 LDKFixedPenaltyScorer* operator &() { return &self; }
1704 LDKFixedPenaltyScorer* operator ->() { return &self; }
1705 const LDKFixedPenaltyScorer* operator &() const { return &self; }
1706 const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1708 class ProbabilisticScorer {
1710 LDKProbabilisticScorer self;
1712 ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1713 ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1714 ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1715 operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1716 ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1717 ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1718 LDKProbabilisticScorer* operator &() { return &self; }
1719 LDKProbabilisticScorer* operator ->() { return &self; }
1720 const LDKProbabilisticScorer* operator &() const { return &self; }
1721 const LDKProbabilisticScorer* operator ->() const { return &self; }
1723 class ProbabilisticScoringFeeParameters {
1725 LDKProbabilisticScoringFeeParameters self;
1727 ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
1728 ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
1729 ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
1730 operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
1731 ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
1732 ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
1733 LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
1734 LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
1735 const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
1736 const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
1738 class ProbabilisticScoringDecayParameters {
1740 LDKProbabilisticScoringDecayParameters self;
1742 ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
1743 ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
1744 ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
1745 operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
1746 ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
1747 ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
1748 LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
1749 LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
1750 const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
1751 const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
1757 BestBlock(const BestBlock&) = delete;
1758 BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
1759 BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
1760 operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
1761 ~BestBlock() { BestBlock_free(self); }
1762 BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
1763 LDKBestBlock* operator &() { return &self; }
1764 LDKBestBlock* operator ->() { return &self; }
1765 const LDKBestBlock* operator &() const { return &self; }
1766 const LDKBestBlock* operator ->() const { return &self; }
1772 Listen(const Listen&) = delete;
1773 Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
1774 Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
1775 operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
1776 ~Listen() { Listen_free(self); }
1777 Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
1778 LDKListen* operator &() { return &self; }
1779 LDKListen* operator ->() { return &self; }
1780 const LDKListen* operator &() const { return &self; }
1781 const LDKListen* operator ->() const { return &self; }
1783 * Notifies the listener that a block was added at the given height, with the transaction data
1784 * possibly filtered.
1786 inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1788 * Notifies the listener that a block was added at the given height.
1790 inline void block_connected(struct LDKu8slice block, uint32_t height);
1792 * Notifies the listener that a block was removed at the given height.
1794 inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
1800 Confirm(const Confirm&) = delete;
1801 Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
1802 Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
1803 operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
1804 ~Confirm() { Confirm_free(self); }
1805 Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
1806 LDKConfirm* operator &() { return &self; }
1807 LDKConfirm* operator ->() { return &self; }
1808 const LDKConfirm* operator &() const { return &self; }
1809 const LDKConfirm* operator ->() const { return &self; }
1811 * Notifies LDK of transactions confirmed in a block with a given header and height.
1813 * Must be called for any transactions registered by [`Filter::register_tx`] or any
1814 * transactions spending an output registered by [`Filter::register_output`]. Such transactions
1815 * appearing in the same block do not need to be included in the same call; instead, multiple
1816 * calls with additional transactions may be made so long as they are made in [chain order].
1818 * May be called before or after [`best_block_updated`] for the corresponding block. However,
1819 * in the event of a chain reorganization, it must not be called with a `header` that is no
1820 * longer in the chain as of the last call to [`best_block_updated`].
1822 * [chain order]: Confirm#order
1823 * [`best_block_updated`]: Self::best_block_updated
1825 inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1827 * Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
1829 * Must be called for any transaction returned by [`get_relevant_txids`] if it has been
1830 * reorganized out of the best chain or if it is no longer confirmed in the block with the
1831 * given block hash. Once called, the given transaction will not be returned
1832 * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
1834 * [`get_relevant_txids`]: Self::get_relevant_txids
1835 * [`transactions_confirmed`]: Self::transactions_confirmed
1837 inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
1839 * Notifies LDK of an update to the best header connected at the given height.
1841 * Must be called whenever a new chain tip becomes available. May be skipped for intermediary
1844 inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
1846 * Returns transactions that must be monitored for reorganization out of the chain along
1847 * with the hash of the block as part of which it had been previously confirmed.
1849 * Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
1850 * 0.0.112 and prior, in which case you need to manually track previous confirmations.
1852 * Will include any transactions passed to [`transactions_confirmed`] that have insufficient
1853 * confirmations to be safe from a chain reorganization. Will not include any transactions
1854 * passed to [`transaction_unconfirmed`], unless later reconfirmed.
1856 * Must be called to determine the subset of transactions that must be monitored for
1857 * reorganization. Will be idempotent between calls but may change as a result of calls to the
1858 * other interface methods. Thus, this is useful to determine which transactions must be
1859 * given to [`transaction_unconfirmed`].
1861 * If any of the returned transactions are confirmed in a block other than the one with the
1862 * given hash, they need to be unconfirmed and reconfirmed via [`transaction_unconfirmed`] and
1863 * [`transactions_confirmed`], respectively.
1865 * [`transactions_confirmed`]: Self::transactions_confirmed
1866 * [`transaction_unconfirmed`]: Self::transaction_unconfirmed
1868 inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ get_relevant_txids();
1870 class ChannelMonitorUpdateStatus {
1872 LDKChannelMonitorUpdateStatus self;
1874 ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
1875 ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
1876 ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
1877 operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
1878 ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
1879 LDKChannelMonitorUpdateStatus* operator &() { return &self; }
1880 LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
1881 const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
1882 const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
1888 Watch(const Watch&) = delete;
1889 Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
1890 Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
1891 operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
1892 ~Watch() { Watch_free(self); }
1893 Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
1894 LDKWatch* operator &() { return &self; }
1895 LDKWatch* operator ->() { return &self; }
1896 const LDKWatch* operator &() const { return &self; }
1897 const LDKWatch* operator ->() const { return &self; }
1899 * Watches a channel identified by `funding_txo` using `monitor`.
1901 * Implementations are responsible for watching the chain for the funding transaction along
1902 * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
1903 * calling [`block_connected`] and [`block_disconnected`] on the monitor.
1905 * A return of `Err(())` indicates that the channel should immediately be force-closed without
1906 * broadcasting the funding transaction.
1908 * If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
1911 * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
1912 * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
1913 * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
1915 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
1917 * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
1919 * Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
1920 * may fail (returning an `Err(())`), in which case this should return
1921 * [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
1922 * generally implies the channel has been closed (either by the funding outpoint being spent
1923 * on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
1924 * and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
1926 * In general, persistence failures should be retried after returning
1927 * [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
1928 * cannot be retried, the node should shut down immediately after returning
1929 * [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
1931 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1933 inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
1935 * Returns any monitor events since the last call. Subsequent calls must only return new
1938 * Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
1939 * further events may be returned here until the [`ChannelMonitor`] has been fully persisted
1942 * For details on asynchronous [`ChannelMonitor`] updating and returning
1943 * [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
1945 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
1951 Filter(const Filter&) = delete;
1952 Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
1953 Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
1954 operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
1955 ~Filter() { Filter_free(self); }
1956 Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
1957 LDKFilter* operator &() { return &self; }
1958 LDKFilter* operator ->() { return &self; }
1959 const LDKFilter* operator &() const { return &self; }
1960 const LDKFilter* operator ->() const { return &self; }
1962 * Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
1963 * a spending condition.
1965 inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
1967 * Registers interest in spends of a transaction output.
1969 * Note that this method might be called during processing of a new block. You therefore need
1970 * to ensure that also dependent output spents within an already connected block are correctly
1971 * handled, e.g., by re-scanning the block in question whenever new outputs have been
1972 * registered mid-processing.
1974 inline void register_output(struct LDKWatchedOutput output);
1976 class WatchedOutput {
1978 LDKWatchedOutput self;
1980 WatchedOutput(const WatchedOutput&) = delete;
1981 WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
1982 WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
1983 operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
1984 ~WatchedOutput() { WatchedOutput_free(self); }
1985 WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
1986 LDKWatchedOutput* operator &() { return &self; }
1987 LDKWatchedOutput* operator ->() { return &self; }
1988 const LDKWatchedOutput* operator &() const { return &self; }
1989 const LDKWatchedOutput* operator ->() const { return &self; }
1991 class InitFeatures {
1993 LDKInitFeatures self;
1995 InitFeatures(const InitFeatures&) = delete;
1996 InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
1997 InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
1998 operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
1999 ~InitFeatures() { InitFeatures_free(self); }
2000 InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
2001 LDKInitFeatures* operator &() { return &self; }
2002 LDKInitFeatures* operator ->() { return &self; }
2003 const LDKInitFeatures* operator &() const { return &self; }
2004 const LDKInitFeatures* operator ->() const { return &self; }
2006 class NodeFeatures {
2008 LDKNodeFeatures self;
2010 NodeFeatures(const NodeFeatures&) = delete;
2011 NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
2012 NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
2013 operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
2014 ~NodeFeatures() { NodeFeatures_free(self); }
2015 NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
2016 LDKNodeFeatures* operator &() { return &self; }
2017 LDKNodeFeatures* operator ->() { return &self; }
2018 const LDKNodeFeatures* operator &() const { return &self; }
2019 const LDKNodeFeatures* operator ->() const { return &self; }
2021 class ChannelFeatures {
2023 LDKChannelFeatures self;
2025 ChannelFeatures(const ChannelFeatures&) = delete;
2026 ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
2027 ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
2028 operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
2029 ~ChannelFeatures() { ChannelFeatures_free(self); }
2030 ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
2031 LDKChannelFeatures* operator &() { return &self; }
2032 LDKChannelFeatures* operator ->() { return &self; }
2033 const LDKChannelFeatures* operator &() const { return &self; }
2034 const LDKChannelFeatures* operator ->() const { return &self; }
2036 class Bolt11InvoiceFeatures {
2038 LDKBolt11InvoiceFeatures self;
2040 Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
2041 Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
2042 Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
2043 operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
2044 ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
2045 Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
2046 LDKBolt11InvoiceFeatures* operator &() { return &self; }
2047 LDKBolt11InvoiceFeatures* operator ->() { return &self; }
2048 const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
2049 const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
2051 class OfferFeatures {
2053 LDKOfferFeatures self;
2055 OfferFeatures(const OfferFeatures&) = delete;
2056 OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
2057 OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
2058 operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
2059 ~OfferFeatures() { OfferFeatures_free(self); }
2060 OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
2061 LDKOfferFeatures* operator &() { return &self; }
2062 LDKOfferFeatures* operator ->() { return &self; }
2063 const LDKOfferFeatures* operator &() const { return &self; }
2064 const LDKOfferFeatures* operator ->() const { return &self; }
2066 class InvoiceRequestFeatures {
2068 LDKInvoiceRequestFeatures self;
2070 InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
2071 InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
2072 InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
2073 operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
2074 ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
2075 InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
2076 LDKInvoiceRequestFeatures* operator &() { return &self; }
2077 LDKInvoiceRequestFeatures* operator ->() { return &self; }
2078 const LDKInvoiceRequestFeatures* operator &() const { return &self; }
2079 const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
2081 class Bolt12InvoiceFeatures {
2083 LDKBolt12InvoiceFeatures self;
2085 Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
2086 Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
2087 Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
2088 operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
2089 ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
2090 Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
2091 LDKBolt12InvoiceFeatures* operator &() { return &self; }
2092 LDKBolt12InvoiceFeatures* operator ->() { return &self; }
2093 const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
2094 const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
2096 class BlindedHopFeatures {
2098 LDKBlindedHopFeatures self;
2100 BlindedHopFeatures(const BlindedHopFeatures&) = delete;
2101 BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
2102 BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
2103 operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
2104 ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
2105 BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
2106 LDKBlindedHopFeatures* operator &() { return &self; }
2107 LDKBlindedHopFeatures* operator ->() { return &self; }
2108 const LDKBlindedHopFeatures* operator &() const { return &self; }
2109 const LDKBlindedHopFeatures* operator ->() const { return &self; }
2111 class ChannelTypeFeatures {
2113 LDKChannelTypeFeatures self;
2115 ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
2116 ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
2117 ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
2118 operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
2119 ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
2120 ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
2121 LDKChannelTypeFeatures* operator &() { return &self; }
2122 LDKChannelTypeFeatures* operator ->() { return &self; }
2123 const LDKChannelTypeFeatures* operator &() const { return &self; }
2124 const LDKChannelTypeFeatures* operator ->() const { return &self; }
2130 Offer(const Offer&) = delete;
2131 Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
2132 Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
2133 operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
2134 ~Offer() { Offer_free(self); }
2135 Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
2136 LDKOffer* operator &() { return &self; }
2137 LDKOffer* operator ->() { return &self; }
2138 const LDKOffer* operator &() const { return &self; }
2139 const LDKOffer* operator ->() const { return &self; }
2145 Amount(const Amount&) = delete;
2146 Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
2147 Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
2148 operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
2149 ~Amount() { Amount_free(self); }
2150 Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
2151 LDKAmount* operator &() { return &self; }
2152 LDKAmount* operator ->() { return &self; }
2153 const LDKAmount* operator &() const { return &self; }
2154 const LDKAmount* operator ->() const { return &self; }
2160 Quantity(const Quantity&) = delete;
2161 Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
2162 Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
2163 operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
2164 ~Quantity() { Quantity_free(self); }
2165 Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
2166 LDKQuantity* operator &() { return &self; }
2167 LDKQuantity* operator ->() { return &self; }
2168 const LDKQuantity* operator &() const { return &self; }
2169 const LDKQuantity* operator ->() const { return &self; }
2175 NodeId(const NodeId&) = delete;
2176 NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2177 NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2178 operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2179 ~NodeId() { NodeId_free(self); }
2180 NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2181 LDKNodeId* operator &() { return &self; }
2182 LDKNodeId* operator ->() { return &self; }
2183 const LDKNodeId* operator &() const { return &self; }
2184 const LDKNodeId* operator ->() const { return &self; }
2186 class NetworkGraph {
2188 LDKNetworkGraph self;
2190 NetworkGraph(const NetworkGraph&) = delete;
2191 NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2192 NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2193 operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2194 ~NetworkGraph() { NetworkGraph_free(self); }
2195 NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2196 LDKNetworkGraph* operator &() { return &self; }
2197 LDKNetworkGraph* operator ->() { return &self; }
2198 const LDKNetworkGraph* operator &() const { return &self; }
2199 const LDKNetworkGraph* operator ->() const { return &self; }
2201 class ReadOnlyNetworkGraph {
2203 LDKReadOnlyNetworkGraph self;
2205 ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2206 ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2207 ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2208 operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2209 ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2210 ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2211 LDKReadOnlyNetworkGraph* operator &() { return &self; }
2212 LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2213 const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2214 const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2216 class NetworkUpdate {
2218 LDKNetworkUpdate self;
2220 NetworkUpdate(const NetworkUpdate&) = delete;
2221 NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2222 NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2223 operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2224 ~NetworkUpdate() { NetworkUpdate_free(self); }
2225 NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2226 LDKNetworkUpdate* operator &() { return &self; }
2227 LDKNetworkUpdate* operator ->() { return &self; }
2228 const LDKNetworkUpdate* operator &() const { return &self; }
2229 const LDKNetworkUpdate* operator ->() const { return &self; }
2231 class P2PGossipSync {
2233 LDKP2PGossipSync self;
2235 P2PGossipSync(const P2PGossipSync&) = delete;
2236 P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
2237 P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
2238 operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
2239 ~P2PGossipSync() { P2PGossipSync_free(self); }
2240 P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
2241 LDKP2PGossipSync* operator &() { return &self; }
2242 LDKP2PGossipSync* operator ->() { return &self; }
2243 const LDKP2PGossipSync* operator &() const { return &self; }
2244 const LDKP2PGossipSync* operator ->() const { return &self; }
2246 class ChannelUpdateInfo {
2248 LDKChannelUpdateInfo self;
2250 ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2251 ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2252 ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2253 operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2254 ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2255 ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2256 LDKChannelUpdateInfo* operator &() { return &self; }
2257 LDKChannelUpdateInfo* operator ->() { return &self; }
2258 const LDKChannelUpdateInfo* operator &() const { return &self; }
2259 const LDKChannelUpdateInfo* operator ->() const { return &self; }
2263 LDKChannelInfo self;
2265 ChannelInfo(const ChannelInfo&) = delete;
2266 ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2267 ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2268 operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2269 ~ChannelInfo() { ChannelInfo_free(self); }
2270 ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2271 LDKChannelInfo* operator &() { return &self; }
2272 LDKChannelInfo* operator ->() { return &self; }
2273 const LDKChannelInfo* operator &() const { return &self; }
2274 const LDKChannelInfo* operator ->() const { return &self; }
2276 class DirectedChannelInfo {
2278 LDKDirectedChannelInfo self;
2280 DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2281 DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2282 DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2283 operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2284 ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2285 DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2286 LDKDirectedChannelInfo* operator &() { return &self; }
2287 LDKDirectedChannelInfo* operator ->() { return &self; }
2288 const LDKDirectedChannelInfo* operator &() const { return &self; }
2289 const LDKDirectedChannelInfo* operator ->() const { return &self; }
2291 class EffectiveCapacity {
2293 LDKEffectiveCapacity self;
2295 EffectiveCapacity(const EffectiveCapacity&) = delete;
2296 EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2297 EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2298 operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2299 ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2300 EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2301 LDKEffectiveCapacity* operator &() { return &self; }
2302 LDKEffectiveCapacity* operator ->() { return &self; }
2303 const LDKEffectiveCapacity* operator &() const { return &self; }
2304 const LDKEffectiveCapacity* operator ->() const { return &self; }
2308 LDKRoutingFees self;
2310 RoutingFees(const RoutingFees&) = delete;
2311 RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2312 RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2313 operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2314 ~RoutingFees() { RoutingFees_free(self); }
2315 RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2316 LDKRoutingFees* operator &() { return &self; }
2317 LDKRoutingFees* operator ->() { return &self; }
2318 const LDKRoutingFees* operator &() const { return &self; }
2319 const LDKRoutingFees* operator ->() const { return &self; }
2321 class NodeAnnouncementInfo {
2323 LDKNodeAnnouncementInfo self;
2325 NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2326 NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2327 NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2328 operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2329 ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2330 NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2331 LDKNodeAnnouncementInfo* operator &() { return &self; }
2332 LDKNodeAnnouncementInfo* operator ->() { return &self; }
2333 const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2334 const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2340 NodeAlias(const NodeAlias&) = delete;
2341 NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
2342 NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
2343 operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
2344 ~NodeAlias() { NodeAlias_free(self); }
2345 NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
2346 LDKNodeAlias* operator &() { return &self; }
2347 LDKNodeAlias* operator ->() { return &self; }
2348 const LDKNodeAlias* operator &() const { return &self; }
2349 const LDKNodeAlias* operator ->() const { return &self; }
2355 NodeInfo(const NodeInfo&) = delete;
2356 NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2357 NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2358 operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2359 ~NodeInfo() { NodeInfo_free(self); }
2360 NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2361 LDKNodeInfo* operator &() { return &self; }
2362 LDKNodeInfo* operator ->() { return &self; }
2363 const LDKNodeInfo* operator &() const { return &self; }
2364 const LDKNodeInfo* operator ->() const { return &self; }
2366 class ChannelDerivationParameters {
2368 LDKChannelDerivationParameters self;
2370 ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
2371 ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
2372 ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
2373 operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
2374 ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
2375 ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
2376 LDKChannelDerivationParameters* operator &() { return &self; }
2377 LDKChannelDerivationParameters* operator ->() { return &self; }
2378 const LDKChannelDerivationParameters* operator &() const { return &self; }
2379 const LDKChannelDerivationParameters* operator ->() const { return &self; }
2381 class AnchorDescriptor {
2383 LDKAnchorDescriptor self;
2385 AnchorDescriptor(const AnchorDescriptor&) = delete;
2386 AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
2387 AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
2388 operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
2389 ~AnchorDescriptor() { AnchorDescriptor_free(self); }
2390 AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
2391 LDKAnchorDescriptor* operator &() { return &self; }
2392 LDKAnchorDescriptor* operator ->() { return &self; }
2393 const LDKAnchorDescriptor* operator &() const { return &self; }
2394 const LDKAnchorDescriptor* operator ->() const { return &self; }
2396 class HTLCDescriptor {
2398 LDKHTLCDescriptor self;
2400 HTLCDescriptor(const HTLCDescriptor&) = delete;
2401 HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
2402 HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
2403 operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
2404 ~HTLCDescriptor() { HTLCDescriptor_free(self); }
2405 HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
2406 LDKHTLCDescriptor* operator &() { return &self; }
2407 LDKHTLCDescriptor* operator ->() { return &self; }
2408 const LDKHTLCDescriptor* operator &() const { return &self; }
2409 const LDKHTLCDescriptor* operator ->() const { return &self; }
2411 class BumpTransactionEvent {
2413 LDKBumpTransactionEvent self;
2415 BumpTransactionEvent(const BumpTransactionEvent&) = delete;
2416 BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
2417 BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
2418 operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
2419 ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
2420 BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
2421 LDKBumpTransactionEvent* operator &() { return &self; }
2422 LDKBumpTransactionEvent* operator ->() { return &self; }
2423 const LDKBumpTransactionEvent* operator &() const { return &self; }
2424 const LDKBumpTransactionEvent* operator ->() const { return &self; }
2430 Input(const Input&) = delete;
2431 Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
2432 Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
2433 operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
2434 ~Input() { Input_free(self); }
2435 Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
2436 LDKInput* operator &() { return &self; }
2437 LDKInput* operator ->() { return &self; }
2438 const LDKInput* operator &() const { return &self; }
2439 const LDKInput* operator ->() const { return &self; }
2445 Utxo(const Utxo&) = delete;
2446 Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
2447 Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
2448 operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
2449 ~Utxo() { Utxo_free(self); }
2450 Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
2451 LDKUtxo* operator &() { return &self; }
2452 LDKUtxo* operator ->() { return &self; }
2453 const LDKUtxo* operator &() const { return &self; }
2454 const LDKUtxo* operator ->() const { return &self; }
2456 class CoinSelection {
2458 LDKCoinSelection self;
2460 CoinSelection(const CoinSelection&) = delete;
2461 CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
2462 CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
2463 operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
2464 ~CoinSelection() { CoinSelection_free(self); }
2465 CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
2466 LDKCoinSelection* operator &() { return &self; }
2467 LDKCoinSelection* operator ->() { return &self; }
2468 const LDKCoinSelection* operator &() const { return &self; }
2469 const LDKCoinSelection* operator ->() const { return &self; }
2471 class CoinSelectionSource {
2473 LDKCoinSelectionSource self;
2475 CoinSelectionSource(const CoinSelectionSource&) = delete;
2476 CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
2477 CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
2478 operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
2479 ~CoinSelectionSource() { CoinSelectionSource_free(self); }
2480 CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
2481 LDKCoinSelectionSource* operator &() { return &self; }
2482 LDKCoinSelectionSource* operator ->() { return &self; }
2483 const LDKCoinSelectionSource* operator &() const { return &self; }
2484 const LDKCoinSelectionSource* operator ->() const { return &self; }
2486 * Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
2487 * available to spend. Implementations are free to pick their coin selection algorithm of
2488 * choice, as long as the following requirements are met:
2490 * 1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
2491 * throughout coin selection, but must not be returned as part of the result.
2492 * 2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
2493 * throughout coin selection. In some cases, like when funding an anchor transaction, this
2494 * set is empty. Implementations should ensure they handle this correctly on their end,
2495 * e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
2496 * provided, in which case a zero-value empty OP_RETURN output can be used instead.
2497 * 3. Enough inputs must be selected/contributed for the resulting transaction (including the
2498 * inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
2500 * Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
2501 * the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
2502 * providing the full input weight. Failing to do so may lead to underestimating fee bumps and
2503 * delaying block inclusion.
2505 * The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
2506 * can be re-used within new fee-bumped iterations of the original claiming transaction,
2507 * ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
2508 * transaction associated with it, and all of the available UTXOs have already been assigned to
2509 * other claims, implementations must be willing to double spend their UTXOs. The choice of
2510 * which UTXOs to double spend is left to the implementation, but it must strive to keep the
2511 * set of other claims being double spent to a minimum.
2513 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);
2515 * Signs and provides the full witness for all inputs within the transaction known to the
2516 * trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
2518 inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
2520 class WalletSource {
2522 LDKWalletSource self;
2524 WalletSource(const WalletSource&) = delete;
2525 WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
2526 WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
2527 operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
2528 ~WalletSource() { WalletSource_free(self); }
2529 WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
2530 LDKWalletSource* operator &() { return &self; }
2531 LDKWalletSource* operator ->() { return &self; }
2532 const LDKWalletSource* operator &() const { return &self; }
2533 const LDKWalletSource* operator ->() const { return &self; }
2535 * Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
2537 inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
2539 * Returns a script to use for change above dust resulting from a successful coin selection
2542 inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
2544 * Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
2545 * the transaction known to the wallet (i.e., any provided via
2546 * [`WalletSource::list_confirmed_utxos`]).
2548 inline LDK::CResult_TransactionNoneZ sign_tx(struct LDKTransaction tx);
2554 Wallet(const Wallet&) = delete;
2555 Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
2556 Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
2557 operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
2558 ~Wallet() { Wallet_free(self); }
2559 Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
2560 LDKWallet* operator &() { return &self; }
2561 LDKWallet* operator ->() { return &self; }
2562 const LDKWallet* operator &() const { return &self; }
2563 const LDKWallet* operator ->() const { return &self; }
2565 class BumpTransactionEventHandler {
2567 LDKBumpTransactionEventHandler self;
2569 BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
2570 BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
2571 BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
2572 operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
2573 ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
2574 BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
2575 LDKBumpTransactionEventHandler* operator &() { return &self; }
2576 LDKBumpTransactionEventHandler* operator ->() { return &self; }
2577 const LDKBumpTransactionEventHandler* operator &() const { return &self; }
2578 const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
2582 LDKFailureCode self;
2584 FailureCode(const FailureCode&) = delete;
2585 FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
2586 FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
2587 operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
2588 ~FailureCode() { FailureCode_free(self); }
2589 FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
2590 LDKFailureCode* operator &() { return &self; }
2591 LDKFailureCode* operator ->() { return &self; }
2592 const LDKFailureCode* operator &() const { return &self; }
2593 const LDKFailureCode* operator ->() const { return &self; }
2595 class ChannelManager {
2597 LDKChannelManager self;
2599 ChannelManager(const ChannelManager&) = delete;
2600 ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
2601 ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
2602 operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
2603 ~ChannelManager() { ChannelManager_free(self); }
2604 ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
2605 LDKChannelManager* operator &() { return &self; }
2606 LDKChannelManager* operator ->() { return &self; }
2607 const LDKChannelManager* operator &() const { return &self; }
2608 const LDKChannelManager* operator ->() const { return &self; }
2610 class ChainParameters {
2612 LDKChainParameters self;
2614 ChainParameters(const ChainParameters&) = delete;
2615 ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
2616 ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
2617 operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
2618 ~ChainParameters() { ChainParameters_free(self); }
2619 ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
2620 LDKChainParameters* operator &() { return &self; }
2621 LDKChainParameters* operator ->() { return &self; }
2622 const LDKChainParameters* operator &() const { return &self; }
2623 const LDKChainParameters* operator ->() const { return &self; }
2625 class CounterpartyForwardingInfo {
2627 LDKCounterpartyForwardingInfo self;
2629 CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
2630 CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
2631 CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
2632 operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
2633 ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
2634 CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
2635 LDKCounterpartyForwardingInfo* operator &() { return &self; }
2636 LDKCounterpartyForwardingInfo* operator ->() { return &self; }
2637 const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
2638 const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
2640 class ChannelCounterparty {
2642 LDKChannelCounterparty self;
2644 ChannelCounterparty(const ChannelCounterparty&) = delete;
2645 ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
2646 ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
2647 operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
2648 ~ChannelCounterparty() { ChannelCounterparty_free(self); }
2649 ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
2650 LDKChannelCounterparty* operator &() { return &self; }
2651 LDKChannelCounterparty* operator ->() { return &self; }
2652 const LDKChannelCounterparty* operator &() const { return &self; }
2653 const LDKChannelCounterparty* operator ->() const { return &self; }
2655 class ChannelDetails {
2657 LDKChannelDetails self;
2659 ChannelDetails(const ChannelDetails&) = delete;
2660 ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
2661 ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
2662 operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
2663 ~ChannelDetails() { ChannelDetails_free(self); }
2664 ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
2665 LDKChannelDetails* operator &() { return &self; }
2666 LDKChannelDetails* operator ->() { return &self; }
2667 const LDKChannelDetails* operator &() const { return &self; }
2668 const LDKChannelDetails* operator ->() const { return &self; }
2670 class ChannelShutdownState {
2672 LDKChannelShutdownState self;
2674 ChannelShutdownState(const ChannelShutdownState&) = delete;
2675 ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
2676 ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
2677 operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
2678 ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
2679 LDKChannelShutdownState* operator &() { return &self; }
2680 LDKChannelShutdownState* operator ->() { return &self; }
2681 const LDKChannelShutdownState* operator &() const { return &self; }
2682 const LDKChannelShutdownState* operator ->() const { return &self; }
2684 class RecentPaymentDetails {
2686 LDKRecentPaymentDetails self;
2688 RecentPaymentDetails(const RecentPaymentDetails&) = delete;
2689 RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
2690 RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
2691 operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
2692 ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
2693 RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
2694 LDKRecentPaymentDetails* operator &() { return &self; }
2695 LDKRecentPaymentDetails* operator ->() { return &self; }
2696 const LDKRecentPaymentDetails* operator &() const { return &self; }
2697 const LDKRecentPaymentDetails* operator ->() const { return &self; }
2699 class PhantomRouteHints {
2701 LDKPhantomRouteHints self;
2703 PhantomRouteHints(const PhantomRouteHints&) = delete;
2704 PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
2705 PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
2706 operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
2707 ~PhantomRouteHints() { PhantomRouteHints_free(self); }
2708 PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
2709 LDKPhantomRouteHints* operator &() { return &self; }
2710 LDKPhantomRouteHints* operator ->() { return &self; }
2711 const LDKPhantomRouteHints* operator &() const { return &self; }
2712 const LDKPhantomRouteHints* operator ->() const { return &self; }
2714 class ChannelManagerReadArgs {
2716 LDKChannelManagerReadArgs self;
2718 ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
2719 ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
2720 ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
2721 operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
2722 ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
2723 ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
2724 LDKChannelManagerReadArgs* operator &() { return &self; }
2725 LDKChannelManagerReadArgs* operator ->() { return &self; }
2726 const LDKChannelManagerReadArgs* operator &() const { return &self; }
2727 const LDKChannelManagerReadArgs* operator ->() const { return &self; }
2729 class ChannelHandshakeConfig {
2731 LDKChannelHandshakeConfig self;
2733 ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
2734 ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
2735 ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
2736 operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
2737 ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
2738 ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
2739 LDKChannelHandshakeConfig* operator &() { return &self; }
2740 LDKChannelHandshakeConfig* operator ->() { return &self; }
2741 const LDKChannelHandshakeConfig* operator &() const { return &self; }
2742 const LDKChannelHandshakeConfig* operator ->() const { return &self; }
2744 class ChannelHandshakeLimits {
2746 LDKChannelHandshakeLimits self;
2748 ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
2749 ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
2750 ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
2751 operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
2752 ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
2753 ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
2754 LDKChannelHandshakeLimits* operator &() { return &self; }
2755 LDKChannelHandshakeLimits* operator ->() { return &self; }
2756 const LDKChannelHandshakeLimits* operator &() const { return &self; }
2757 const LDKChannelHandshakeLimits* operator ->() const { return &self; }
2759 class MaxDustHTLCExposure {
2761 LDKMaxDustHTLCExposure self;
2763 MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
2764 MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
2765 MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
2766 operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
2767 ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
2768 MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
2769 LDKMaxDustHTLCExposure* operator &() { return &self; }
2770 LDKMaxDustHTLCExposure* operator ->() { return &self; }
2771 const LDKMaxDustHTLCExposure* operator &() const { return &self; }
2772 const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
2774 class ChannelConfig {
2776 LDKChannelConfig self;
2778 ChannelConfig(const ChannelConfig&) = delete;
2779 ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
2780 ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
2781 operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
2782 ~ChannelConfig() { ChannelConfig_free(self); }
2783 ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
2784 LDKChannelConfig* operator &() { return &self; }
2785 LDKChannelConfig* operator ->() { return &self; }
2786 const LDKChannelConfig* operator &() const { return &self; }
2787 const LDKChannelConfig* operator ->() const { return &self; }
2789 class ChannelConfigUpdate {
2791 LDKChannelConfigUpdate self;
2793 ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
2794 ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
2795 ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
2796 operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
2797 ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
2798 ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
2799 LDKChannelConfigUpdate* operator &() { return &self; }
2800 LDKChannelConfigUpdate* operator ->() { return &self; }
2801 const LDKChannelConfigUpdate* operator &() const { return &self; }
2802 const LDKChannelConfigUpdate* operator ->() const { return &self; }
2808 UserConfig(const UserConfig&) = delete;
2809 UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
2810 UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
2811 operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
2812 ~UserConfig() { UserConfig_free(self); }
2813 UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
2814 LDKUserConfig* operator &() { return &self; }
2815 LDKUserConfig* operator ->() { return &self; }
2816 const LDKUserConfig* operator &() const { return &self; }
2817 const LDKUserConfig* operator ->() const { return &self; }
2823 APIError(const APIError&) = delete;
2824 APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
2825 APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
2826 operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
2827 ~APIError() { APIError_free(self); }
2828 APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
2829 LDKAPIError* operator &() { return &self; }
2830 LDKAPIError* operator ->() { return &self; }
2831 const LDKAPIError* operator &() const { return &self; }
2832 const LDKAPIError* operator ->() const { return &self; }
2838 TaggedHash(const TaggedHash&) = delete;
2839 TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
2840 TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
2841 operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
2842 ~TaggedHash() { TaggedHash_free(self); }
2843 TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
2844 LDKTaggedHash* operator &() { return &self; }
2845 LDKTaggedHash* operator ->() { return &self; }
2846 const LDKTaggedHash* operator &() const { return &self; }
2847 const LDKTaggedHash* operator ->() const { return &self; }
2849 class ChannelMonitorUpdate {
2851 LDKChannelMonitorUpdate self;
2853 ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
2854 ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
2855 ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
2856 operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
2857 ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
2858 ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
2859 LDKChannelMonitorUpdate* operator &() { return &self; }
2860 LDKChannelMonitorUpdate* operator ->() { return &self; }
2861 const LDKChannelMonitorUpdate* operator &() const { return &self; }
2862 const LDKChannelMonitorUpdate* operator ->() const { return &self; }
2864 class MonitorEvent {
2866 LDKMonitorEvent self;
2868 MonitorEvent(const MonitorEvent&) = delete;
2869 MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
2870 MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
2871 operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
2872 ~MonitorEvent() { MonitorEvent_free(self); }
2873 MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
2874 LDKMonitorEvent* operator &() { return &self; }
2875 LDKMonitorEvent* operator ->() { return &self; }
2876 const LDKMonitorEvent* operator &() const { return &self; }
2877 const LDKMonitorEvent* operator ->() const { return &self; }
2883 HTLCUpdate(const HTLCUpdate&) = delete;
2884 HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
2885 HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
2886 operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
2887 ~HTLCUpdate() { HTLCUpdate_free(self); }
2888 HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
2889 LDKHTLCUpdate* operator &() { return &self; }
2890 LDKHTLCUpdate* operator ->() { return &self; }
2891 const LDKHTLCUpdate* operator &() const { return &self; }
2892 const LDKHTLCUpdate* operator ->() const { return &self; }
2898 Balance(const Balance&) = delete;
2899 Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
2900 Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
2901 operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
2902 ~Balance() { Balance_free(self); }
2903 Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
2904 LDKBalance* operator &() { return &self; }
2905 LDKBalance* operator ->() { return &self; }
2906 const LDKBalance* operator &() const { return &self; }
2907 const LDKBalance* operator ->() const { return &self; }
2909 class ChannelMonitor {
2911 LDKChannelMonitor self;
2913 ChannelMonitor(const ChannelMonitor&) = delete;
2914 ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
2915 ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
2916 operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
2917 ~ChannelMonitor() { ChannelMonitor_free(self); }
2918 ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
2919 LDKChannelMonitor* operator &() { return &self; }
2920 LDKChannelMonitor* operator ->() { return &self; }
2921 const LDKChannelMonitor* operator &() const { return &self; }
2922 const LDKChannelMonitor* operator ->() const { return &self; }
2926 LDKExpandedKey self;
2928 ExpandedKey(const ExpandedKey&) = delete;
2929 ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
2930 ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
2931 operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
2932 ~ExpandedKey() { ExpandedKey_free(self); }
2933 ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
2934 LDKExpandedKey* operator &() { return &self; }
2935 LDKExpandedKey* operator ->() { return &self; }
2936 const LDKExpandedKey* operator &() const { return &self; }
2937 const LDKExpandedKey* operator ->() const { return &self; }
2939 class CustomMessageHandler {
2941 LDKCustomMessageHandler self;
2943 CustomMessageHandler(const CustomMessageHandler&) = delete;
2944 CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
2945 CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
2946 operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
2947 ~CustomMessageHandler() { CustomMessageHandler_free(self); }
2948 CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
2949 LDKCustomMessageHandler* operator &() { return &self; }
2950 LDKCustomMessageHandler* operator ->() { return &self; }
2951 const LDKCustomMessageHandler* operator &() const { return &self; }
2952 const LDKCustomMessageHandler* operator ->() const { return &self; }
2954 * Handles the given message sent from `sender_node_id`, possibly producing messages for
2955 * [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
2958 inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
2960 * Returns the list of pending messages that were generated by the handler, clearing the list
2961 * in the process. Each message is paired with the node id of the intended recipient. If no
2962 * connection to the node exists, then the message is simply not sent.
2964 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
2966 * Gets the node feature flags which this handler itself supports. All available handlers are
2967 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
2968 * which are broadcasted in our [`NodeAnnouncement`] message.
2970 * [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
2972 inline LDK::NodeFeatures provided_node_features();
2974 * Gets the init feature flags which should be sent to the given peer. All available handlers
2975 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
2976 * which are sent in our [`Init`] message.
2978 * [`Init`]: crate::ln::msgs::Init
2980 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
2982 class IgnoringMessageHandler {
2984 LDKIgnoringMessageHandler self;
2986 IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
2987 IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
2988 IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
2989 operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
2990 ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
2991 IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
2992 LDKIgnoringMessageHandler* operator &() { return &self; }
2993 LDKIgnoringMessageHandler* operator ->() { return &self; }
2994 const LDKIgnoringMessageHandler* operator &() const { return &self; }
2995 const LDKIgnoringMessageHandler* operator ->() const { return &self; }
2997 class ErroringMessageHandler {
2999 LDKErroringMessageHandler self;
3001 ErroringMessageHandler(const ErroringMessageHandler&) = delete;
3002 ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
3003 ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
3004 operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
3005 ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
3006 ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
3007 LDKErroringMessageHandler* operator &() { return &self; }
3008 LDKErroringMessageHandler* operator ->() { return &self; }
3009 const LDKErroringMessageHandler* operator &() const { return &self; }
3010 const LDKErroringMessageHandler* operator ->() const { return &self; }
3012 class MessageHandler {
3014 LDKMessageHandler self;
3016 MessageHandler(const MessageHandler&) = delete;
3017 MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
3018 MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
3019 operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
3020 ~MessageHandler() { MessageHandler_free(self); }
3021 MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
3022 LDKMessageHandler* operator &() { return &self; }
3023 LDKMessageHandler* operator ->() { return &self; }
3024 const LDKMessageHandler* operator &() const { return &self; }
3025 const LDKMessageHandler* operator ->() const { return &self; }
3027 class SocketDescriptor {
3029 LDKSocketDescriptor self;
3031 SocketDescriptor(const SocketDescriptor&) = delete;
3032 SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
3033 SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
3034 operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
3035 ~SocketDescriptor() { SocketDescriptor_free(self); }
3036 SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
3037 LDKSocketDescriptor* operator &() { return &self; }
3038 LDKSocketDescriptor* operator ->() { return &self; }
3039 const LDKSocketDescriptor* operator &() const { return &self; }
3040 const LDKSocketDescriptor* operator ->() const { return &self; }
3042 * Attempts to send some data from the given slice to the peer.
3044 * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
3045 * Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
3046 * called and further write attempts may occur until that time.
3048 * If the returned size is smaller than `data.len()`, a
3049 * [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
3050 * written. Additionally, until a `send_data` event completes fully, no further
3051 * [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
3052 * prevent denial-of-service issues, you should not read or buffer any data from the socket
3055 * If a [`PeerManager::read_event`] call on this descriptor had previously returned true
3056 * (indicating that read events should be paused to prevent DoS in the send buffer),
3057 * `resume_read` may be set indicating that read events on this descriptor should resume. A
3058 * `resume_read` of false carries no meaning, and should not cause any action.
3060 inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
3062 * Disconnect the socket pointed to by this SocketDescriptor.
3064 * You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
3065 * call (doing so is a noop).
3067 inline void disconnect_socket();
3068 /** Checks if two objects are equal given this object's this_arg pointer and another object. */
3069 inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
3071 * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
3072 * This is used, for example, for inclusion of this object in a hash map.
3074 inline uint64_t hash();
3076 class PeerHandleError {
3078 LDKPeerHandleError self;
3080 PeerHandleError(const PeerHandleError&) = delete;
3081 PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
3082 PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
3083 operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
3084 ~PeerHandleError() { PeerHandleError_free(self); }
3085 PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
3086 LDKPeerHandleError* operator &() { return &self; }
3087 LDKPeerHandleError* operator ->() { return &self; }
3088 const LDKPeerHandleError* operator &() const { return &self; }
3089 const LDKPeerHandleError* operator ->() const { return &self; }
3093 LDKPeerManager self;
3095 PeerManager(const PeerManager&) = delete;
3096 PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
3097 PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
3098 operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
3099 ~PeerManager() { PeerManager_free(self); }
3100 PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
3101 LDKPeerManager* operator &() { return &self; }
3102 LDKPeerManager* operator ->() { return &self; }
3103 const LDKPeerManager* operator &() const { return &self; }
3104 const LDKPeerManager* operator ->() const { return &self; }
3106 class RapidGossipSync {
3108 LDKRapidGossipSync self;
3110 RapidGossipSync(const RapidGossipSync&) = delete;
3111 RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
3112 RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
3113 operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
3114 ~RapidGossipSync() { RapidGossipSync_free(self); }
3115 RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
3116 LDKRapidGossipSync* operator &() { return &self; }
3117 LDKRapidGossipSync* operator ->() { return &self; }
3118 const LDKRapidGossipSync* operator &() const { return &self; }
3119 const LDKRapidGossipSync* operator ->() const { return &self; }
3125 KVStore(const KVStore&) = delete;
3126 KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
3127 KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
3128 operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
3129 ~KVStore() { KVStore_free(self); }
3130 KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
3131 LDKKVStore* operator &() { return &self; }
3132 LDKKVStore* operator ->() { return &self; }
3133 const LDKKVStore* operator &() const { return &self; }
3134 const LDKKVStore* operator ->() const { return &self; }
3136 * Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
3139 * Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
3140 * `primary_namespace` and `secondary_namespace`.
3142 * [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
3144 inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
3146 * Persists the given data under the given `key`.
3148 * Will create the given `primary_namespace` and `secondary_namespace` if not already present
3151 inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
3153 * Removes any data that had previously been persisted under the given `key`.
3155 * If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
3156 * remove the given `key` at some point in time after the method returns, e.g., as part of an
3157 * eventual batch deletion of multiple keys. As a consequence, subsequent calls to
3158 * [`KVStore::list`] might include the removed key until the changes are actually persisted.
3160 * Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
3161 * `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
3162 * potentially get lost on crash after the method returns. Therefore, this flag should only be
3163 * set for `remove` operations that can be safely replayed at a later time.
3165 * Returns successfully if no data will be stored for the given `primary_namespace`,
3166 * `secondary_namespace`, and `key`, independently of whether it was present before its
3167 * invokation or not.
3169 inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
3171 * Returns a list of keys that are stored under the given `secondary_namespace` in
3172 * `primary_namespace`.
3174 * Returns the keys in arbitrary order, so users requiring a particular order need to sort the
3175 * returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
3177 inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
3183 Persister(const Persister&) = delete;
3184 Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
3185 Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
3186 operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
3187 ~Persister() { Persister_free(self); }
3188 Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
3189 LDKPersister* operator &() { return &self; }
3190 LDKPersister* operator ->() { return &self; }
3191 const LDKPersister* operator &() const { return &self; }
3192 const LDKPersister* operator ->() const { return &self; }
3194 * Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
3196 inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
3198 * Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
3200 inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
3202 * Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
3204 inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
3206 class MonitorUpdatingPersister {
3208 LDKMonitorUpdatingPersister self;
3210 MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
3211 MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
3212 MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
3213 operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
3214 ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
3215 MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
3216 LDKMonitorUpdatingPersister* operator &() { return &self; }
3217 LDKMonitorUpdatingPersister* operator ->() { return &self; }
3218 const LDKMonitorUpdatingPersister* operator &() const { return &self; }
3219 const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
3221 class UnsignedInvoiceRequest {
3223 LDKUnsignedInvoiceRequest self;
3225 UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
3226 UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
3227 UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
3228 operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
3229 ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
3230 UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
3231 LDKUnsignedInvoiceRequest* operator &() { return &self; }
3232 LDKUnsignedInvoiceRequest* operator ->() { return &self; }
3233 const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
3234 const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
3236 class InvoiceRequest {
3238 LDKInvoiceRequest self;
3240 InvoiceRequest(const InvoiceRequest&) = delete;
3241 InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
3242 InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
3243 operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
3244 ~InvoiceRequest() { InvoiceRequest_free(self); }
3245 InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
3246 LDKInvoiceRequest* operator &() { return &self; }
3247 LDKInvoiceRequest* operator ->() { return &self; }
3248 const LDKInvoiceRequest* operator &() const { return &self; }
3249 const LDKInvoiceRequest* operator ->() const { return &self; }
3251 class VerifiedInvoiceRequest {
3253 LDKVerifiedInvoiceRequest self;
3255 VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
3256 VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
3257 VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
3258 operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
3259 ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
3260 VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
3261 LDKVerifiedInvoiceRequest* operator &() { return &self; }
3262 LDKVerifiedInvoiceRequest* operator ->() { return &self; }
3263 const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
3264 const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
3268 LDKDecodeError self;
3270 DecodeError(const DecodeError&) = delete;
3271 DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
3272 DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
3273 operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
3274 ~DecodeError() { DecodeError_free(self); }
3275 DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
3276 LDKDecodeError* operator &() { return &self; }
3277 LDKDecodeError* operator ->() { return &self; }
3278 const LDKDecodeError* operator &() const { return &self; }
3279 const LDKDecodeError* operator ->() const { return &self; }
3285 Init(const Init&) = delete;
3286 Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
3287 Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
3288 operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
3289 ~Init() { Init_free(self); }
3290 Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
3291 LDKInit* operator &() { return &self; }
3292 LDKInit* operator ->() { return &self; }
3293 const LDKInit* operator &() const { return &self; }
3294 const LDKInit* operator ->() const { return &self; }
3296 class ErrorMessage {
3298 LDKErrorMessage self;
3300 ErrorMessage(const ErrorMessage&) = delete;
3301 ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
3302 ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
3303 operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
3304 ~ErrorMessage() { ErrorMessage_free(self); }
3305 ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
3306 LDKErrorMessage* operator &() { return &self; }
3307 LDKErrorMessage* operator ->() { return &self; }
3308 const LDKErrorMessage* operator &() const { return &self; }
3309 const LDKErrorMessage* operator ->() const { return &self; }
3311 class WarningMessage {
3313 LDKWarningMessage self;
3315 WarningMessage(const WarningMessage&) = delete;
3316 WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
3317 WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
3318 operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
3319 ~WarningMessage() { WarningMessage_free(self); }
3320 WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
3321 LDKWarningMessage* operator &() { return &self; }
3322 LDKWarningMessage* operator ->() { return &self; }
3323 const LDKWarningMessage* operator &() const { return &self; }
3324 const LDKWarningMessage* operator ->() const { return &self; }
3330 Ping(const Ping&) = delete;
3331 Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
3332 Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
3333 operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
3334 ~Ping() { Ping_free(self); }
3335 Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
3336 LDKPing* operator &() { return &self; }
3337 LDKPing* operator ->() { return &self; }
3338 const LDKPing* operator &() const { return &self; }
3339 const LDKPing* operator ->() const { return &self; }
3345 Pong(const Pong&) = delete;
3346 Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
3347 Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
3348 operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
3349 ~Pong() { Pong_free(self); }
3350 Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
3351 LDKPong* operator &() { return &self; }
3352 LDKPong* operator ->() { return &self; }
3353 const LDKPong* operator &() const { return &self; }
3354 const LDKPong* operator ->() const { return &self; }
3358 LDKOpenChannel self;
3360 OpenChannel(const OpenChannel&) = delete;
3361 OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
3362 OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
3363 operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
3364 ~OpenChannel() { OpenChannel_free(self); }
3365 OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
3366 LDKOpenChannel* operator &() { return &self; }
3367 LDKOpenChannel* operator ->() { return &self; }
3368 const LDKOpenChannel* operator &() const { return &self; }
3369 const LDKOpenChannel* operator ->() const { return &self; }
3371 class OpenChannelV2 {
3373 LDKOpenChannelV2 self;
3375 OpenChannelV2(const OpenChannelV2&) = delete;
3376 OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
3377 OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
3378 operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
3379 ~OpenChannelV2() { OpenChannelV2_free(self); }
3380 OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
3381 LDKOpenChannelV2* operator &() { return &self; }
3382 LDKOpenChannelV2* operator ->() { return &self; }
3383 const LDKOpenChannelV2* operator &() const { return &self; }
3384 const LDKOpenChannelV2* operator ->() const { return &self; }
3386 class AcceptChannel {
3388 LDKAcceptChannel self;
3390 AcceptChannel(const AcceptChannel&) = delete;
3391 AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
3392 AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
3393 operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
3394 ~AcceptChannel() { AcceptChannel_free(self); }
3395 AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
3396 LDKAcceptChannel* operator &() { return &self; }
3397 LDKAcceptChannel* operator ->() { return &self; }
3398 const LDKAcceptChannel* operator &() const { return &self; }
3399 const LDKAcceptChannel* operator ->() const { return &self; }
3401 class AcceptChannelV2 {
3403 LDKAcceptChannelV2 self;
3405 AcceptChannelV2(const AcceptChannelV2&) = delete;
3406 AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
3407 AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
3408 operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
3409 ~AcceptChannelV2() { AcceptChannelV2_free(self); }
3410 AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
3411 LDKAcceptChannelV2* operator &() { return &self; }
3412 LDKAcceptChannelV2* operator ->() { return &self; }
3413 const LDKAcceptChannelV2* operator &() const { return &self; }
3414 const LDKAcceptChannelV2* operator ->() const { return &self; }
3416 class FundingCreated {
3418 LDKFundingCreated self;
3420 FundingCreated(const FundingCreated&) = delete;
3421 FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
3422 FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
3423 operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
3424 ~FundingCreated() { FundingCreated_free(self); }
3425 FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
3426 LDKFundingCreated* operator &() { return &self; }
3427 LDKFundingCreated* operator ->() { return &self; }
3428 const LDKFundingCreated* operator &() const { return &self; }
3429 const LDKFundingCreated* operator ->() const { return &self; }
3431 class FundingSigned {
3433 LDKFundingSigned self;
3435 FundingSigned(const FundingSigned&) = delete;
3436 FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
3437 FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
3438 operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
3439 ~FundingSigned() { FundingSigned_free(self); }
3440 FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
3441 LDKFundingSigned* operator &() { return &self; }
3442 LDKFundingSigned* operator ->() { return &self; }
3443 const LDKFundingSigned* operator &() const { return &self; }
3444 const LDKFundingSigned* operator ->() const { return &self; }
3446 class ChannelReady {
3448 LDKChannelReady self;
3450 ChannelReady(const ChannelReady&) = delete;
3451 ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
3452 ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
3453 operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
3454 ~ChannelReady() { ChannelReady_free(self); }
3455 ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
3456 LDKChannelReady* operator &() { return &self; }
3457 LDKChannelReady* operator ->() { return &self; }
3458 const LDKChannelReady* operator &() const { return &self; }
3459 const LDKChannelReady* operator ->() const { return &self; }
3465 TxAddInput(const TxAddInput&) = delete;
3466 TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
3467 TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
3468 operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
3469 ~TxAddInput() { TxAddInput_free(self); }
3470 TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
3471 LDKTxAddInput* operator &() { return &self; }
3472 LDKTxAddInput* operator ->() { return &self; }
3473 const LDKTxAddInput* operator &() const { return &self; }
3474 const LDKTxAddInput* operator ->() const { return &self; }
3478 LDKTxAddOutput self;
3480 TxAddOutput(const TxAddOutput&) = delete;
3481 TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
3482 TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
3483 operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
3484 ~TxAddOutput() { TxAddOutput_free(self); }
3485 TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
3486 LDKTxAddOutput* operator &() { return &self; }
3487 LDKTxAddOutput* operator ->() { return &self; }
3488 const LDKTxAddOutput* operator &() const { return &self; }
3489 const LDKTxAddOutput* operator ->() const { return &self; }
3491 class TxRemoveInput {
3493 LDKTxRemoveInput self;
3495 TxRemoveInput(const TxRemoveInput&) = delete;
3496 TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
3497 TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
3498 operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
3499 ~TxRemoveInput() { TxRemoveInput_free(self); }
3500 TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
3501 LDKTxRemoveInput* operator &() { return &self; }
3502 LDKTxRemoveInput* operator ->() { return &self; }
3503 const LDKTxRemoveInput* operator &() const { return &self; }
3504 const LDKTxRemoveInput* operator ->() const { return &self; }
3506 class TxRemoveOutput {
3508 LDKTxRemoveOutput self;
3510 TxRemoveOutput(const TxRemoveOutput&) = delete;
3511 TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
3512 TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
3513 operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
3514 ~TxRemoveOutput() { TxRemoveOutput_free(self); }
3515 TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
3516 LDKTxRemoveOutput* operator &() { return &self; }
3517 LDKTxRemoveOutput* operator ->() { return &self; }
3518 const LDKTxRemoveOutput* operator &() const { return &self; }
3519 const LDKTxRemoveOutput* operator ->() const { return &self; }
3525 TxComplete(const TxComplete&) = delete;
3526 TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
3527 TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
3528 operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
3529 ~TxComplete() { TxComplete_free(self); }
3530 TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
3531 LDKTxComplete* operator &() { return &self; }
3532 LDKTxComplete* operator ->() { return &self; }
3533 const LDKTxComplete* operator &() const { return &self; }
3534 const LDKTxComplete* operator ->() const { return &self; }
3536 class TxSignatures {
3538 LDKTxSignatures self;
3540 TxSignatures(const TxSignatures&) = delete;
3541 TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
3542 TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
3543 operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
3544 ~TxSignatures() { TxSignatures_free(self); }
3545 TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
3546 LDKTxSignatures* operator &() { return &self; }
3547 LDKTxSignatures* operator ->() { return &self; }
3548 const LDKTxSignatures* operator &() const { return &self; }
3549 const LDKTxSignatures* operator ->() const { return &self; }
3555 TxInitRbf(const TxInitRbf&) = delete;
3556 TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
3557 TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
3558 operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
3559 ~TxInitRbf() { TxInitRbf_free(self); }
3560 TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
3561 LDKTxInitRbf* operator &() { return &self; }
3562 LDKTxInitRbf* operator ->() { return &self; }
3563 const LDKTxInitRbf* operator &() const { return &self; }
3564 const LDKTxInitRbf* operator ->() const { return &self; }
3570 TxAckRbf(const TxAckRbf&) = delete;
3571 TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
3572 TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
3573 operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
3574 ~TxAckRbf() { TxAckRbf_free(self); }
3575 TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
3576 LDKTxAckRbf* operator &() { return &self; }
3577 LDKTxAckRbf* operator ->() { return &self; }
3578 const LDKTxAckRbf* operator &() const { return &self; }
3579 const LDKTxAckRbf* operator ->() const { return &self; }
3585 TxAbort(const TxAbort&) = delete;
3586 TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
3587 TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
3588 operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
3589 ~TxAbort() { TxAbort_free(self); }
3590 TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
3591 LDKTxAbort* operator &() { return &self; }
3592 LDKTxAbort* operator ->() { return &self; }
3593 const LDKTxAbort* operator &() const { return &self; }
3594 const LDKTxAbort* operator ->() const { return &self; }
3600 Shutdown(const Shutdown&) = delete;
3601 Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
3602 Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
3603 operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
3604 ~Shutdown() { Shutdown_free(self); }
3605 Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
3606 LDKShutdown* operator &() { return &self; }
3607 LDKShutdown* operator ->() { return &self; }
3608 const LDKShutdown* operator &() const { return &self; }
3609 const LDKShutdown* operator ->() const { return &self; }
3611 class ClosingSignedFeeRange {
3613 LDKClosingSignedFeeRange self;
3615 ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
3616 ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
3617 ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
3618 operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
3619 ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
3620 ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
3621 LDKClosingSignedFeeRange* operator &() { return &self; }
3622 LDKClosingSignedFeeRange* operator ->() { return &self; }
3623 const LDKClosingSignedFeeRange* operator &() const { return &self; }
3624 const LDKClosingSignedFeeRange* operator ->() const { return &self; }
3626 class ClosingSigned {
3628 LDKClosingSigned self;
3630 ClosingSigned(const ClosingSigned&) = delete;
3631 ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
3632 ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
3633 operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
3634 ~ClosingSigned() { ClosingSigned_free(self); }
3635 ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
3636 LDKClosingSigned* operator &() { return &self; }
3637 LDKClosingSigned* operator ->() { return &self; }
3638 const LDKClosingSigned* operator &() const { return &self; }
3639 const LDKClosingSigned* operator ->() const { return &self; }
3641 class UpdateAddHTLC {
3643 LDKUpdateAddHTLC self;
3645 UpdateAddHTLC(const UpdateAddHTLC&) = delete;
3646 UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
3647 UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
3648 operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
3649 ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
3650 UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
3651 LDKUpdateAddHTLC* operator &() { return &self; }
3652 LDKUpdateAddHTLC* operator ->() { return &self; }
3653 const LDKUpdateAddHTLC* operator &() const { return &self; }
3654 const LDKUpdateAddHTLC* operator ->() const { return &self; }
3656 class OnionMessage {
3658 LDKOnionMessage self;
3660 OnionMessage(const OnionMessage&) = delete;
3661 OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
3662 OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
3663 operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
3664 ~OnionMessage() { OnionMessage_free(self); }
3665 OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
3666 LDKOnionMessage* operator &() { return &self; }
3667 LDKOnionMessage* operator ->() { return &self; }
3668 const LDKOnionMessage* operator &() const { return &self; }
3669 const LDKOnionMessage* operator ->() const { return &self; }
3671 class UpdateFulfillHTLC {
3673 LDKUpdateFulfillHTLC self;
3675 UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
3676 UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
3677 UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
3678 operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
3679 ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
3680 UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
3681 LDKUpdateFulfillHTLC* operator &() { return &self; }
3682 LDKUpdateFulfillHTLC* operator ->() { return &self; }
3683 const LDKUpdateFulfillHTLC* operator &() const { return &self; }
3684 const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
3686 class UpdateFailHTLC {
3688 LDKUpdateFailHTLC self;
3690 UpdateFailHTLC(const UpdateFailHTLC&) = delete;
3691 UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
3692 UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
3693 operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
3694 ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
3695 UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
3696 LDKUpdateFailHTLC* operator &() { return &self; }
3697 LDKUpdateFailHTLC* operator ->() { return &self; }
3698 const LDKUpdateFailHTLC* operator &() const { return &self; }
3699 const LDKUpdateFailHTLC* operator ->() const { return &self; }
3701 class UpdateFailMalformedHTLC {
3703 LDKUpdateFailMalformedHTLC self;
3705 UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
3706 UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
3707 UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
3708 operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
3709 ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
3710 UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
3711 LDKUpdateFailMalformedHTLC* operator &() { return &self; }
3712 LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
3713 const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
3714 const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
3716 class CommitmentSigned {
3718 LDKCommitmentSigned self;
3720 CommitmentSigned(const CommitmentSigned&) = delete;
3721 CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
3722 CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
3723 operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
3724 ~CommitmentSigned() { CommitmentSigned_free(self); }
3725 CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
3726 LDKCommitmentSigned* operator &() { return &self; }
3727 LDKCommitmentSigned* operator ->() { return &self; }
3728 const LDKCommitmentSigned* operator &() const { return &self; }
3729 const LDKCommitmentSigned* operator ->() const { return &self; }
3731 class RevokeAndACK {
3733 LDKRevokeAndACK self;
3735 RevokeAndACK(const RevokeAndACK&) = delete;
3736 RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
3737 RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
3738 operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
3739 ~RevokeAndACK() { RevokeAndACK_free(self); }
3740 RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
3741 LDKRevokeAndACK* operator &() { return &self; }
3742 LDKRevokeAndACK* operator ->() { return &self; }
3743 const LDKRevokeAndACK* operator &() const { return &self; }
3744 const LDKRevokeAndACK* operator ->() const { return &self; }
3750 UpdateFee(const UpdateFee&) = delete;
3751 UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
3752 UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
3753 operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
3754 ~UpdateFee() { UpdateFee_free(self); }
3755 UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
3756 LDKUpdateFee* operator &() { return &self; }
3757 LDKUpdateFee* operator ->() { return &self; }
3758 const LDKUpdateFee* operator &() const { return &self; }
3759 const LDKUpdateFee* operator ->() const { return &self; }
3761 class ChannelReestablish {
3763 LDKChannelReestablish self;
3765 ChannelReestablish(const ChannelReestablish&) = delete;
3766 ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
3767 ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
3768 operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
3769 ~ChannelReestablish() { ChannelReestablish_free(self); }
3770 ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
3771 LDKChannelReestablish* operator &() { return &self; }
3772 LDKChannelReestablish* operator ->() { return &self; }
3773 const LDKChannelReestablish* operator &() const { return &self; }
3774 const LDKChannelReestablish* operator ->() const { return &self; }
3776 class AnnouncementSignatures {
3778 LDKAnnouncementSignatures self;
3780 AnnouncementSignatures(const AnnouncementSignatures&) = delete;
3781 AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
3782 AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
3783 operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
3784 ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
3785 AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
3786 LDKAnnouncementSignatures* operator &() { return &self; }
3787 LDKAnnouncementSignatures* operator ->() { return &self; }
3788 const LDKAnnouncementSignatures* operator &() const { return &self; }
3789 const LDKAnnouncementSignatures* operator ->() const { return &self; }
3791 class SocketAddress {
3793 LDKSocketAddress self;
3795 SocketAddress(const SocketAddress&) = delete;
3796 SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
3797 SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
3798 operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
3799 ~SocketAddress() { SocketAddress_free(self); }
3800 SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
3801 LDKSocketAddress* operator &() { return &self; }
3802 LDKSocketAddress* operator ->() { return &self; }
3803 const LDKSocketAddress* operator &() const { return &self; }
3804 const LDKSocketAddress* operator ->() const { return &self; }
3806 class SocketAddressParseError {
3808 LDKSocketAddressParseError self;
3810 SocketAddressParseError(const SocketAddressParseError&) = delete;
3811 SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
3812 SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
3813 operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
3814 SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
3815 LDKSocketAddressParseError* operator &() { return &self; }
3816 LDKSocketAddressParseError* operator ->() { return &self; }
3817 const LDKSocketAddressParseError* operator &() const { return &self; }
3818 const LDKSocketAddressParseError* operator ->() const { return &self; }
3820 class UnsignedGossipMessage {
3822 LDKUnsignedGossipMessage self;
3824 UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
3825 UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
3826 UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
3827 operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
3828 ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
3829 UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
3830 LDKUnsignedGossipMessage* operator &() { return &self; }
3831 LDKUnsignedGossipMessage* operator ->() { return &self; }
3832 const LDKUnsignedGossipMessage* operator &() const { return &self; }
3833 const LDKUnsignedGossipMessage* operator ->() const { return &self; }
3835 class UnsignedNodeAnnouncement {
3837 LDKUnsignedNodeAnnouncement self;
3839 UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
3840 UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
3841 UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
3842 operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
3843 ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
3844 UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
3845 LDKUnsignedNodeAnnouncement* operator &() { return &self; }
3846 LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
3847 const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
3848 const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
3850 class NodeAnnouncement {
3852 LDKNodeAnnouncement self;
3854 NodeAnnouncement(const NodeAnnouncement&) = delete;
3855 NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
3856 NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
3857 operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
3858 ~NodeAnnouncement() { NodeAnnouncement_free(self); }
3859 NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
3860 LDKNodeAnnouncement* operator &() { return &self; }
3861 LDKNodeAnnouncement* operator ->() { return &self; }
3862 const LDKNodeAnnouncement* operator &() const { return &self; }
3863 const LDKNodeAnnouncement* operator ->() const { return &self; }
3865 class UnsignedChannelAnnouncement {
3867 LDKUnsignedChannelAnnouncement self;
3869 UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
3870 UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
3871 UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
3872 operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
3873 ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
3874 UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
3875 LDKUnsignedChannelAnnouncement* operator &() { return &self; }
3876 LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
3877 const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
3878 const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
3880 class ChannelAnnouncement {
3882 LDKChannelAnnouncement self;
3884 ChannelAnnouncement(const ChannelAnnouncement&) = delete;
3885 ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
3886 ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
3887 operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
3888 ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
3889 ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
3890 LDKChannelAnnouncement* operator &() { return &self; }
3891 LDKChannelAnnouncement* operator ->() { return &self; }
3892 const LDKChannelAnnouncement* operator &() const { return &self; }
3893 const LDKChannelAnnouncement* operator ->() const { return &self; }
3895 class UnsignedChannelUpdate {
3897 LDKUnsignedChannelUpdate self;
3899 UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
3900 UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
3901 UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
3902 operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
3903 ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
3904 UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
3905 LDKUnsignedChannelUpdate* operator &() { return &self; }
3906 LDKUnsignedChannelUpdate* operator ->() { return &self; }
3907 const LDKUnsignedChannelUpdate* operator &() const { return &self; }
3908 const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
3910 class ChannelUpdate {
3912 LDKChannelUpdate self;
3914 ChannelUpdate(const ChannelUpdate&) = delete;
3915 ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
3916 ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
3917 operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
3918 ~ChannelUpdate() { ChannelUpdate_free(self); }
3919 ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
3920 LDKChannelUpdate* operator &() { return &self; }
3921 LDKChannelUpdate* operator ->() { return &self; }
3922 const LDKChannelUpdate* operator &() const { return &self; }
3923 const LDKChannelUpdate* operator ->() const { return &self; }
3925 class QueryChannelRange {
3927 LDKQueryChannelRange self;
3929 QueryChannelRange(const QueryChannelRange&) = delete;
3930 QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
3931 QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
3932 operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
3933 ~QueryChannelRange() { QueryChannelRange_free(self); }
3934 QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
3935 LDKQueryChannelRange* operator &() { return &self; }
3936 LDKQueryChannelRange* operator ->() { return &self; }
3937 const LDKQueryChannelRange* operator &() const { return &self; }
3938 const LDKQueryChannelRange* operator ->() const { return &self; }
3940 class ReplyChannelRange {
3942 LDKReplyChannelRange self;
3944 ReplyChannelRange(const ReplyChannelRange&) = delete;
3945 ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
3946 ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
3947 operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
3948 ~ReplyChannelRange() { ReplyChannelRange_free(self); }
3949 ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
3950 LDKReplyChannelRange* operator &() { return &self; }
3951 LDKReplyChannelRange* operator ->() { return &self; }
3952 const LDKReplyChannelRange* operator &() const { return &self; }
3953 const LDKReplyChannelRange* operator ->() const { return &self; }
3955 class QueryShortChannelIds {
3957 LDKQueryShortChannelIds self;
3959 QueryShortChannelIds(const QueryShortChannelIds&) = delete;
3960 QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
3961 QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
3962 operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
3963 ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
3964 QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
3965 LDKQueryShortChannelIds* operator &() { return &self; }
3966 LDKQueryShortChannelIds* operator ->() { return &self; }
3967 const LDKQueryShortChannelIds* operator &() const { return &self; }
3968 const LDKQueryShortChannelIds* operator ->() const { return &self; }
3970 class ReplyShortChannelIdsEnd {
3972 LDKReplyShortChannelIdsEnd self;
3974 ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
3975 ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
3976 ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
3977 operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
3978 ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
3979 ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
3980 LDKReplyShortChannelIdsEnd* operator &() { return &self; }
3981 LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
3982 const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
3983 const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
3985 class GossipTimestampFilter {
3987 LDKGossipTimestampFilter self;
3989 GossipTimestampFilter(const GossipTimestampFilter&) = delete;
3990 GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
3991 GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
3992 operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
3993 ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
3994 GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
3995 LDKGossipTimestampFilter* operator &() { return &self; }
3996 LDKGossipTimestampFilter* operator ->() { return &self; }
3997 const LDKGossipTimestampFilter* operator &() const { return &self; }
3998 const LDKGossipTimestampFilter* operator ->() const { return &self; }
4002 LDKErrorAction self;
4004 ErrorAction(const ErrorAction&) = delete;
4005 ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
4006 ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
4007 operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
4008 ~ErrorAction() { ErrorAction_free(self); }
4009 ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
4010 LDKErrorAction* operator &() { return &self; }
4011 LDKErrorAction* operator ->() { return &self; }
4012 const LDKErrorAction* operator &() const { return &self; }
4013 const LDKErrorAction* operator ->() const { return &self; }
4015 class LightningError {
4017 LDKLightningError self;
4019 LightningError(const LightningError&) = delete;
4020 LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
4021 LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
4022 operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
4023 ~LightningError() { LightningError_free(self); }
4024 LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
4025 LDKLightningError* operator &() { return &self; }
4026 LDKLightningError* operator ->() { return &self; }
4027 const LDKLightningError* operator &() const { return &self; }
4028 const LDKLightningError* operator ->() const { return &self; }
4030 class CommitmentUpdate {
4032 LDKCommitmentUpdate self;
4034 CommitmentUpdate(const CommitmentUpdate&) = delete;
4035 CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
4036 CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
4037 operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
4038 ~CommitmentUpdate() { CommitmentUpdate_free(self); }
4039 CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
4040 LDKCommitmentUpdate* operator &() { return &self; }
4041 LDKCommitmentUpdate* operator ->() { return &self; }
4042 const LDKCommitmentUpdate* operator &() const { return &self; }
4043 const LDKCommitmentUpdate* operator ->() const { return &self; }
4045 class ChannelMessageHandler {
4047 LDKChannelMessageHandler self;
4049 ChannelMessageHandler(const ChannelMessageHandler&) = delete;
4050 ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
4051 ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
4052 operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
4053 ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
4054 ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
4055 LDKChannelMessageHandler* operator &() { return &self; }
4056 LDKChannelMessageHandler* operator ->() { return &self; }
4057 const LDKChannelMessageHandler* operator &() const { return &self; }
4058 const LDKChannelMessageHandler* operator ->() const { return &self; }
4060 * Handle an incoming `open_channel` message from the given peer.
4062 inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
4064 * Handle an incoming `open_channel2` message from the given peer.
4066 inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
4068 * Handle an incoming `accept_channel` message from the given peer.
4070 inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
4072 * Handle an incoming `accept_channel2` message from the given peer.
4074 inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
4076 * Handle an incoming `funding_created` message from the given peer.
4078 inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4080 * Handle an incoming `funding_signed` message from the given peer.
4082 inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4084 * Handle an incoming `channel_ready` message from the given peer.
4086 inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
4088 * Handle an incoming `shutdown` message from the given peer.
4090 inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
4092 * Handle an incoming `closing_signed` message from the given peer.
4094 inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4096 * Handle an incoming `tx_add_input message` from the given peer.
4098 inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
4100 * Handle an incoming `tx_add_output` message from the given peer.
4102 inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
4104 * Handle an incoming `tx_remove_input` message from the given peer.
4106 inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
4108 * Handle an incoming `tx_remove_output` message from the given peer.
4110 inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
4112 * Handle an incoming `tx_complete message` from the given peer.
4114 inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
4116 * Handle an incoming `tx_signatures` message from the given peer.
4118 inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
4120 * Handle an incoming `tx_init_rbf` message from the given peer.
4122 inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
4124 * Handle an incoming `tx_ack_rbf` message from the given peer.
4126 inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
4128 * Handle an incoming `tx_abort message` from the given peer.
4130 inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
4132 * Handle an incoming `update_add_htlc` message from the given peer.
4134 inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4136 * Handle an incoming `update_fulfill_htlc` message from the given peer.
4138 inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4140 * Handle an incoming `update_fail_htlc` message from the given peer.
4142 inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4144 * Handle an incoming `update_fail_malformed_htlc` message from the given peer.
4146 inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4148 * Handle an incoming `commitment_signed` message from the given peer.
4150 inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4152 * Handle an incoming `revoke_and_ack` message from the given peer.
4154 inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4156 * Handle an incoming `update_fee` message from the given peer.
4158 inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4160 * Handle an incoming `announcement_signatures` message from the given peer.
4162 inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4164 * Indicates a connection to the peer failed/an existing connection was lost.
4166 inline void peer_disconnected(struct LDKPublicKey their_node_id);
4168 * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
4170 * May return an `Err(())` if the features the peer supports are not sufficient to communicate
4171 * with us. Implementors should be somewhat conservative about doing so, however, as other
4172 * message handlers may still wish to communicate with this peer.
4174 inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
4176 * Handle an incoming `channel_reestablish` message from the given peer.
4178 inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4180 * Handle an incoming `channel_update` message from the given peer.
4182 inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4184 * Handle an incoming `error` message from the given peer.
4186 inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4188 * Gets the node feature flags which this handler itself supports. All available handlers are
4189 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4190 * which are broadcasted in our [`NodeAnnouncement`] message.
4192 inline LDK::NodeFeatures provided_node_features();
4194 * Gets the init feature flags which should be sent to the given peer. All available handlers
4195 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4196 * which are sent in our [`Init`] message.
4198 * Note that this method is called before [`Self::peer_connected`].
4200 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4202 * Gets the genesis hashes for this `ChannelMessageHandler` indicating which chains it supports.
4204 * If it's `None`, then no particular network chain hash compatibility will be enforced when
4205 * connecting to peers.
4207 inline LDK::COption_CVec_ThirtyTwoBytesZZ get_genesis_hashes();
4209 class RoutingMessageHandler {
4211 LDKRoutingMessageHandler self;
4213 RoutingMessageHandler(const RoutingMessageHandler&) = delete;
4214 RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
4215 RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
4216 operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
4217 ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
4218 RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
4219 LDKRoutingMessageHandler* operator &() { return &self; }
4220 LDKRoutingMessageHandler* operator ->() { return &self; }
4221 const LDKRoutingMessageHandler* operator &() const { return &self; }
4222 const LDKRoutingMessageHandler* operator ->() const { return &self; }
4224 * Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
4225 * `false` or returning an `Err` otherwise.
4227 inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4229 * Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
4230 * or returning an `Err` otherwise.
4232 inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4234 * Handle an incoming `channel_update` message, returning true if it should be forwarded on,
4235 * `false` or returning an `Err` otherwise.
4237 inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
4239 * Gets channel announcements and updates required to dump our routing table to a remote node,
4240 * starting at the `short_channel_id` indicated by `starting_point` and including announcements
4241 * for a single channel.
4243 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
4245 * Gets a node announcement required to dump our routing table to a remote node, starting at
4246 * the node *after* the provided pubkey and including up to one announcement immediately
4247 * higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
4248 * If `None` is provided for `starting_point`, we start at the first node.
4250 * Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4251 * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4253 inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
4255 * Called when a connection is established with a peer. This can be used to
4256 * perform routing table synchronization using a strategy defined by the
4259 * May return an `Err(())` if the features the peer supports are not sufficient to communicate
4260 * with us. Implementors should be somewhat conservative about doing so, however, as other
4261 * message handlers may still wish to communicate with this peer.
4263 inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4265 * Handles the reply of a query we initiated to learn about channels
4266 * for a given range of blocks. We can expect to receive one or more
4267 * replies to a single query.
4269 inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
4271 * Handles the reply of a query we initiated asking for routing gossip
4272 * messages for a list of channels. We should receive this message when
4273 * a node has completed its best effort to send us the pertaining routing
4276 inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
4278 * Handles when a peer asks us to send a list of `short_channel_id`s
4279 * for the requested range of blocks.
4281 inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
4283 * Handles when a peer asks us to send routing gossip messages for a
4284 * list of `short_channel_id`s.
4286 inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
4288 * Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
4289 * pending some async action. While there is no guarantee of the rate of future messages, the
4290 * caller should seek to reduce the rate of new gossip messages handled, especially
4291 * [`ChannelAnnouncement`]s.
4293 inline bool processing_queue_high();
4295 * Gets the node feature flags which this handler itself supports. All available handlers are
4296 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4297 * which are broadcasted in our [`NodeAnnouncement`] message.
4299 inline LDK::NodeFeatures provided_node_features();
4301 * Gets the init feature flags which should be sent to the given peer. All available handlers
4302 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4303 * which are sent in our [`Init`] message.
4305 * Note that this method is called before [`Self::peer_connected`].
4307 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4309 class OnionMessageHandler {
4311 LDKOnionMessageHandler self;
4313 OnionMessageHandler(const OnionMessageHandler&) = delete;
4314 OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
4315 OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
4316 operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
4317 ~OnionMessageHandler() { OnionMessageHandler_free(self); }
4318 OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
4319 LDKOnionMessageHandler* operator &() { return &self; }
4320 LDKOnionMessageHandler* operator ->() { return &self; }
4321 const LDKOnionMessageHandler* operator &() const { return &self; }
4322 const LDKOnionMessageHandler* operator ->() const { return &self; }
4324 * Handle an incoming `onion_message` message from the given peer.
4326 inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
4328 * Called when a connection is established with a peer. Can be used to track which peers
4329 * advertise onion message support and are online.
4331 * May return an `Err(())` if the features the peer supports are not sufficient to communicate
4332 * with us. Implementors should be somewhat conservative about doing so, however, as other
4333 * message handlers may still wish to communicate with this peer.
4335 inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4337 * Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
4338 * drop and refuse to forward onion messages to this peer.
4340 inline void peer_disconnected(struct LDKPublicKey their_node_id);
4342 * Gets the node feature flags which this handler itself supports. All available handlers are
4343 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4344 * which are broadcasted in our [`NodeAnnouncement`] message.
4346 inline LDK::NodeFeatures provided_node_features();
4348 * Gets the init feature flags which should be sent to the given peer. All available handlers
4349 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4350 * which are sent in our [`Init`] message.
4352 * Note that this method is called before [`Self::peer_connected`].
4354 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4360 Level(const Level&) = delete;
4361 Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
4362 Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
4363 operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
4364 Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
4365 LDKLevel* operator &() { return &self; }
4366 LDKLevel* operator ->() { return &self; }
4367 const LDKLevel* operator &() const { return &self; }
4368 const LDKLevel* operator ->() const { return &self; }
4374 Record(const Record&) = delete;
4375 Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
4376 Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
4377 operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
4378 ~Record() { Record_free(self); }
4379 Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
4380 LDKRecord* operator &() { return &self; }
4381 LDKRecord* operator ->() { return &self; }
4382 const LDKRecord* operator &() const { return &self; }
4383 const LDKRecord* operator ->() const { return &self; }
4389 Logger(const Logger&) = delete;
4390 Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
4391 Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
4392 operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
4393 ~Logger() { Logger_free(self); }
4394 Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
4395 LDKLogger* operator &() { return &self; }
4396 LDKLogger* operator ->() { return &self; }
4397 const LDKLogger* operator &() const { return &self; }
4398 const LDKLogger* operator ->() const { return &self; }
4402 inline void log(const struct LDKRecord *NONNULL_PTR record);
4404 class FutureCallback {
4406 LDKFutureCallback self;
4408 FutureCallback(const FutureCallback&) = delete;
4409 FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
4410 FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
4411 operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
4412 ~FutureCallback() { FutureCallback_free(self); }
4413 FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
4414 LDKFutureCallback* operator &() { return &self; }
4415 LDKFutureCallback* operator ->() { return &self; }
4416 const LDKFutureCallback* operator &() const { return &self; }
4417 const LDKFutureCallback* operator ->() const { return &self; }
4419 * The method which is called.
4427 Future(const Future&) = delete;
4428 Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
4429 Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
4430 operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
4431 ~Future() { Future_free(self); }
4432 Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
4433 LDKFuture* operator &() { return &self; }
4434 LDKFuture* operator ->() { return &self; }
4435 const LDKFuture* operator &() const { return &self; }
4436 const LDKFuture* operator ->() const { return &self; }
4442 Sleeper(const Sleeper&) = delete;
4443 Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
4444 Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
4445 operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
4446 ~Sleeper() { Sleeper_free(self); }
4447 Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
4448 LDKSleeper* operator &() { return &self; }
4449 LDKSleeper* operator ->() { return &self; }
4450 const LDKSleeper* operator &() const { return &self; }
4451 const LDKSleeper* operator ->() const { return &self; }
4453 class OffersMessageHandler {
4455 LDKOffersMessageHandler self;
4457 OffersMessageHandler(const OffersMessageHandler&) = delete;
4458 OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
4459 OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
4460 operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
4461 ~OffersMessageHandler() { OffersMessageHandler_free(self); }
4462 OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
4463 LDKOffersMessageHandler* operator &() { return &self; }
4464 LDKOffersMessageHandler* operator ->() { return &self; }
4465 const LDKOffersMessageHandler* operator &() const { return &self; }
4466 const LDKOffersMessageHandler* operator ->() const { return &self; }
4468 * Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
4469 * or replying with an error.
4471 inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
4473 class OffersMessage {
4475 LDKOffersMessage self;
4477 OffersMessage(const OffersMessage&) = delete;
4478 OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
4479 OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
4480 operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
4481 ~OffersMessage() { OffersMessage_free(self); }
4482 OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
4483 LDKOffersMessage* operator &() { return &self; }
4484 LDKOffersMessage* operator ->() { return &self; }
4485 const LDKOffersMessage* operator &() const { return &self; }
4486 const LDKOffersMessage* operator ->() const { return &self; }
4492 HTLCClaim(const HTLCClaim&) = delete;
4493 HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
4494 HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
4495 operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
4496 HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
4497 LDKHTLCClaim* operator &() { return &self; }
4498 LDKHTLCClaim* operator ->() { return &self; }
4499 const LDKHTLCClaim* operator &() const { return &self; }
4500 const LDKHTLCClaim* operator ->() const { return &self; }
4502 class CounterpartyCommitmentSecrets {
4504 LDKCounterpartyCommitmentSecrets self;
4506 CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
4507 CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
4508 CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
4509 operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
4510 ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
4511 CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
4512 LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
4513 LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
4514 const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
4515 const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
4517 class TxCreationKeys {
4519 LDKTxCreationKeys self;
4521 TxCreationKeys(const TxCreationKeys&) = delete;
4522 TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
4523 TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
4524 operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
4525 ~TxCreationKeys() { TxCreationKeys_free(self); }
4526 TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
4527 LDKTxCreationKeys* operator &() { return &self; }
4528 LDKTxCreationKeys* operator ->() { return &self; }
4529 const LDKTxCreationKeys* operator &() const { return &self; }
4530 const LDKTxCreationKeys* operator ->() const { return &self; }
4532 class ChannelPublicKeys {
4534 LDKChannelPublicKeys self;
4536 ChannelPublicKeys(const ChannelPublicKeys&) = delete;
4537 ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
4538 ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
4539 operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
4540 ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
4541 ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
4542 LDKChannelPublicKeys* operator &() { return &self; }
4543 LDKChannelPublicKeys* operator ->() { return &self; }
4544 const LDKChannelPublicKeys* operator &() const { return &self; }
4545 const LDKChannelPublicKeys* operator ->() const { return &self; }
4547 class HTLCOutputInCommitment {
4549 LDKHTLCOutputInCommitment self;
4551 HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
4552 HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
4553 HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
4554 operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
4555 ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
4556 HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
4557 LDKHTLCOutputInCommitment* operator &() { return &self; }
4558 LDKHTLCOutputInCommitment* operator ->() { return &self; }
4559 const LDKHTLCOutputInCommitment* operator &() const { return &self; }
4560 const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
4562 class ChannelTransactionParameters {
4564 LDKChannelTransactionParameters self;
4566 ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
4567 ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
4568 ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
4569 operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
4570 ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
4571 ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
4572 LDKChannelTransactionParameters* operator &() { return &self; }
4573 LDKChannelTransactionParameters* operator ->() { return &self; }
4574 const LDKChannelTransactionParameters* operator &() const { return &self; }
4575 const LDKChannelTransactionParameters* operator ->() const { return &self; }
4577 class CounterpartyChannelTransactionParameters {
4579 LDKCounterpartyChannelTransactionParameters self;
4581 CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
4582 CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
4583 CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
4584 operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
4585 ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
4586 CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
4587 LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
4588 LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
4589 const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
4590 const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
4592 class DirectedChannelTransactionParameters {
4594 LDKDirectedChannelTransactionParameters self;
4596 DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
4597 DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
4598 DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
4599 operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
4600 ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
4601 DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
4602 LDKDirectedChannelTransactionParameters* operator &() { return &self; }
4603 LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
4604 const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
4605 const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
4607 class HolderCommitmentTransaction {
4609 LDKHolderCommitmentTransaction self;
4611 HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
4612 HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
4613 HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
4614 operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
4615 ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
4616 HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
4617 LDKHolderCommitmentTransaction* operator &() { return &self; }
4618 LDKHolderCommitmentTransaction* operator ->() { return &self; }
4619 const LDKHolderCommitmentTransaction* operator &() const { return &self; }
4620 const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
4622 class BuiltCommitmentTransaction {
4624 LDKBuiltCommitmentTransaction self;
4626 BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
4627 BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
4628 BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
4629 operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
4630 ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
4631 BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
4632 LDKBuiltCommitmentTransaction* operator &() { return &self; }
4633 LDKBuiltCommitmentTransaction* operator ->() { return &self; }
4634 const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
4635 const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
4637 class ClosingTransaction {
4639 LDKClosingTransaction self;
4641 ClosingTransaction(const ClosingTransaction&) = delete;
4642 ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
4643 ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
4644 operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
4645 ~ClosingTransaction() { ClosingTransaction_free(self); }
4646 ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
4647 LDKClosingTransaction* operator &() { return &self; }
4648 LDKClosingTransaction* operator ->() { return &self; }
4649 const LDKClosingTransaction* operator &() const { return &self; }
4650 const LDKClosingTransaction* operator ->() const { return &self; }
4652 class TrustedClosingTransaction {
4654 LDKTrustedClosingTransaction self;
4656 TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
4657 TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
4658 TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
4659 operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
4660 ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
4661 TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
4662 LDKTrustedClosingTransaction* operator &() { return &self; }
4663 LDKTrustedClosingTransaction* operator ->() { return &self; }
4664 const LDKTrustedClosingTransaction* operator &() const { return &self; }
4665 const LDKTrustedClosingTransaction* operator ->() const { return &self; }
4667 class CommitmentTransaction {
4669 LDKCommitmentTransaction self;
4671 CommitmentTransaction(const CommitmentTransaction&) = delete;
4672 CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
4673 CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
4674 operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
4675 ~CommitmentTransaction() { CommitmentTransaction_free(self); }
4676 CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
4677 LDKCommitmentTransaction* operator &() { return &self; }
4678 LDKCommitmentTransaction* operator ->() { return &self; }
4679 const LDKCommitmentTransaction* operator &() const { return &self; }
4680 const LDKCommitmentTransaction* operator ->() const { return &self; }
4682 class TrustedCommitmentTransaction {
4684 LDKTrustedCommitmentTransaction self;
4686 TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
4687 TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
4688 TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
4689 operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
4690 ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
4691 TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
4692 LDKTrustedCommitmentTransaction* operator &() { return &self; }
4693 LDKTrustedCommitmentTransaction* operator ->() { return &self; }
4694 const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
4695 const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
4697 class ShutdownScript {
4699 LDKShutdownScript self;
4701 ShutdownScript(const ShutdownScript&) = delete;
4702 ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
4703 ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
4704 operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
4705 ~ShutdownScript() { ShutdownScript_free(self); }
4706 ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
4707 LDKShutdownScript* operator &() { return &self; }
4708 LDKShutdownScript* operator ->() { return &self; }
4709 const LDKShutdownScript* operator &() const { return &self; }
4710 const LDKShutdownScript* operator ->() const { return &self; }
4712 class InvalidShutdownScript {
4714 LDKInvalidShutdownScript self;
4716 InvalidShutdownScript(const InvalidShutdownScript&) = delete;
4717 InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
4718 InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
4719 operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
4720 ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
4721 InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
4722 LDKInvalidShutdownScript* operator &() { return &self; }
4723 LDKInvalidShutdownScript* operator ->() { return &self; }
4724 const LDKInvalidShutdownScript* operator &() const { return &self; }
4725 const LDKInvalidShutdownScript* operator ->() const { return &self; }
4727 class Bolt12ParseError {
4729 LDKBolt12ParseError self;
4731 Bolt12ParseError(const Bolt12ParseError&) = delete;
4732 Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
4733 Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
4734 operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
4735 ~Bolt12ParseError() { Bolt12ParseError_free(self); }
4736 Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
4737 LDKBolt12ParseError* operator &() { return &self; }
4738 LDKBolt12ParseError* operator ->() { return &self; }
4739 const LDKBolt12ParseError* operator &() const { return &self; }
4740 const LDKBolt12ParseError* operator ->() const { return &self; }
4742 class Bolt12SemanticError {
4744 LDKBolt12SemanticError self;
4746 Bolt12SemanticError(const Bolt12SemanticError&) = delete;
4747 Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
4748 Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
4749 operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
4750 Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
4751 LDKBolt12SemanticError* operator &() { return &self; }
4752 LDKBolt12SemanticError* operator ->() { return &self; }
4753 const LDKBolt12SemanticError* operator &() const { return &self; }
4754 const LDKBolt12SemanticError* operator ->() const { return &self; }
4756 class BroadcasterInterface {
4758 LDKBroadcasterInterface self;
4760 BroadcasterInterface(const BroadcasterInterface&) = delete;
4761 BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
4762 BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
4763 operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
4764 ~BroadcasterInterface() { BroadcasterInterface_free(self); }
4765 BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
4766 LDKBroadcasterInterface* operator &() { return &self; }
4767 LDKBroadcasterInterface* operator ->() { return &self; }
4768 const LDKBroadcasterInterface* operator &() const { return &self; }
4769 const LDKBroadcasterInterface* operator ->() const { return &self; }
4771 * Sends a list of transactions out to (hopefully) be mined.
4772 * This only needs to handle the actual broadcasting of transactions, LDK will automatically
4773 * rebroadcast transactions that haven't made it into a block.
4775 * In some cases LDK may attempt to broadcast a transaction which double-spends another
4776 * and this isn't a bug and can be safely ignored.
4778 * If more than one transaction is given, these transactions should be considered to be a
4779 * package and broadcast together. Some of the transactions may or may not depend on each other,
4780 * be sure to manage both cases correctly.
4782 * Bitcoin transaction packages are defined in BIP 331 and here:
4783 * https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md
4785 inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
4787 class ConfirmationTarget {
4789 LDKConfirmationTarget self;
4791 ConfirmationTarget(const ConfirmationTarget&) = delete;
4792 ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
4793 ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
4794 operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
4795 ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
4796 LDKConfirmationTarget* operator &() { return &self; }
4797 LDKConfirmationTarget* operator ->() { return &self; }
4798 const LDKConfirmationTarget* operator &() const { return &self; }
4799 const LDKConfirmationTarget* operator ->() const { return &self; }
4801 class FeeEstimator {
4803 LDKFeeEstimator self;
4805 FeeEstimator(const FeeEstimator&) = delete;
4806 FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
4807 FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
4808 operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
4809 ~FeeEstimator() { FeeEstimator_free(self); }
4810 FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
4811 LDKFeeEstimator* operator &() { return &self; }
4812 LDKFeeEstimator* operator ->() { return &self; }
4813 const LDKFeeEstimator* operator &() const { return &self; }
4814 const LDKFeeEstimator* operator ->() const { return &self; }
4816 * Gets estimated satoshis of fee required per 1000 Weight-Units.
4818 * LDK will wrap this method and ensure that the value returned is no smaller than 253
4819 * (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
4821 * The following unit conversions can be used to convert to sats/KW:
4822 * * satoshis-per-byte * 250
4823 * * satoshis-per-kbyte / 4
4825 inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
4831 Packet(const Packet&) = delete;
4832 Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
4833 Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
4834 operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
4835 ~Packet() { Packet_free(self); }
4836 Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
4837 LDKPacket* operator &() { return &self; }
4838 LDKPacket* operator ->() { return &self; }
4839 const LDKPacket* operator &() const { return &self; }
4840 const LDKPacket* operator ->() const { return &self; }
4842 class OnionMessageContents {
4844 LDKOnionMessageContents self;
4846 OnionMessageContents(const OnionMessageContents&) = delete;
4847 OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
4848 OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
4849 operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
4850 ~OnionMessageContents() { OnionMessageContents_free(self); }
4851 OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
4852 LDKOnionMessageContents* operator &() { return &self; }
4853 LDKOnionMessageContents* operator ->() { return &self; }
4854 const LDKOnionMessageContents* operator &() const { return &self; }
4855 const LDKOnionMessageContents* operator ->() const { return &self; }
4857 class CustomOnionMessageContents {
4859 LDKCustomOnionMessageContents self;
4861 CustomOnionMessageContents(const CustomOnionMessageContents&) = delete;
4862 CustomOnionMessageContents(CustomOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageContents)); }
4863 CustomOnionMessageContents(LDKCustomOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageContents)); }
4864 operator LDKCustomOnionMessageContents() && { LDKCustomOnionMessageContents res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageContents)); return res; }
4865 ~CustomOnionMessageContents() { CustomOnionMessageContents_free(self); }
4866 CustomOnionMessageContents& operator=(CustomOnionMessageContents&& o) { CustomOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageContents)); return *this; }
4867 LDKCustomOnionMessageContents* operator &() { return &self; }
4868 LDKCustomOnionMessageContents* operator ->() { return &self; }
4869 const LDKCustomOnionMessageContents* operator &() const { return &self; }
4870 const LDKCustomOnionMessageContents* operator ->() const { return &self; }
4872 * Returns the TLV type identifying the message contents. MUST be >= 64.
4874 inline uint64_t tlv_type();
4876 class PaymentPurpose {
4878 LDKPaymentPurpose self;
4880 PaymentPurpose(const PaymentPurpose&) = delete;
4881 PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
4882 PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
4883 operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
4884 ~PaymentPurpose() { PaymentPurpose_free(self); }
4885 PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
4886 LDKPaymentPurpose* operator &() { return &self; }
4887 LDKPaymentPurpose* operator ->() { return &self; }
4888 const LDKPaymentPurpose* operator &() const { return &self; }
4889 const LDKPaymentPurpose* operator ->() const { return &self; }
4893 LDKClaimedHTLC self;
4895 ClaimedHTLC(const ClaimedHTLC&) = delete;
4896 ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
4897 ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
4898 operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
4899 ~ClaimedHTLC() { ClaimedHTLC_free(self); }
4900 ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
4901 LDKClaimedHTLC* operator &() { return &self; }
4902 LDKClaimedHTLC* operator ->() { return &self; }
4903 const LDKClaimedHTLC* operator &() const { return &self; }
4904 const LDKClaimedHTLC* operator ->() const { return &self; }
4908 LDKPathFailure self;
4910 PathFailure(const PathFailure&) = delete;
4911 PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
4912 PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
4913 operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
4914 ~PathFailure() { PathFailure_free(self); }
4915 PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
4916 LDKPathFailure* operator &() { return &self; }
4917 LDKPathFailure* operator ->() { return &self; }
4918 const LDKPathFailure* operator &() const { return &self; }
4919 const LDKPathFailure* operator ->() const { return &self; }
4921 class ClosureReason {
4923 LDKClosureReason self;
4925 ClosureReason(const ClosureReason&) = delete;
4926 ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
4927 ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
4928 operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
4929 ~ClosureReason() { ClosureReason_free(self); }
4930 ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
4931 LDKClosureReason* operator &() { return &self; }
4932 LDKClosureReason* operator ->() { return &self; }
4933 const LDKClosureReason* operator &() const { return &self; }
4934 const LDKClosureReason* operator ->() const { return &self; }
4936 class HTLCDestination {
4938 LDKHTLCDestination self;
4940 HTLCDestination(const HTLCDestination&) = delete;
4941 HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
4942 HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
4943 operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
4944 ~HTLCDestination() { HTLCDestination_free(self); }
4945 HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
4946 LDKHTLCDestination* operator &() { return &self; }
4947 LDKHTLCDestination* operator ->() { return &self; }
4948 const LDKHTLCDestination* operator &() const { return &self; }
4949 const LDKHTLCDestination* operator ->() const { return &self; }
4951 class PaymentFailureReason {
4953 LDKPaymentFailureReason self;
4955 PaymentFailureReason(const PaymentFailureReason&) = delete;
4956 PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
4957 PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
4958 operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
4959 PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
4960 LDKPaymentFailureReason* operator &() { return &self; }
4961 LDKPaymentFailureReason* operator ->() { return &self; }
4962 const LDKPaymentFailureReason* operator &() const { return &self; }
4963 const LDKPaymentFailureReason* operator ->() const { return &self; }
4969 Event(const Event&) = delete;
4970 Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
4971 Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
4972 operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
4973 ~Event() { Event_free(self); }
4974 Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
4975 LDKEvent* operator &() { return &self; }
4976 LDKEvent* operator ->() { return &self; }
4977 const LDKEvent* operator &() const { return &self; }
4978 const LDKEvent* operator ->() const { return &self; }
4980 class MessageSendEvent {
4982 LDKMessageSendEvent self;
4984 MessageSendEvent(const MessageSendEvent&) = delete;
4985 MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
4986 MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
4987 operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
4988 ~MessageSendEvent() { MessageSendEvent_free(self); }
4989 MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
4990 LDKMessageSendEvent* operator &() { return &self; }
4991 LDKMessageSendEvent* operator ->() { return &self; }
4992 const LDKMessageSendEvent* operator &() const { return &self; }
4993 const LDKMessageSendEvent* operator ->() const { return &self; }
4995 class MessageSendEventsProvider {
4997 LDKMessageSendEventsProvider self;
4999 MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
5000 MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
5001 MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
5002 operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
5003 ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
5004 MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
5005 LDKMessageSendEventsProvider* operator &() { return &self; }
5006 LDKMessageSendEventsProvider* operator ->() { return &self; }
5007 const LDKMessageSendEventsProvider* operator &() const { return &self; }
5008 const LDKMessageSendEventsProvider* operator ->() const { return &self; }
5010 * Gets the list of pending events which were generated by previous actions, clearing the list
5013 inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
5015 class OnionMessageProvider {
5017 LDKOnionMessageProvider self;
5019 OnionMessageProvider(const OnionMessageProvider&) = delete;
5020 OnionMessageProvider(OnionMessageProvider&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageProvider)); }
5021 OnionMessageProvider(LDKOnionMessageProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageProvider)); }
5022 operator LDKOnionMessageProvider() && { LDKOnionMessageProvider res = self; memset(&self, 0, sizeof(LDKOnionMessageProvider)); return res; }
5023 ~OnionMessageProvider() { OnionMessageProvider_free(self); }
5024 OnionMessageProvider& operator=(OnionMessageProvider&& o) { OnionMessageProvider_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageProvider)); return *this; }
5025 LDKOnionMessageProvider* operator &() { return &self; }
5026 LDKOnionMessageProvider* operator ->() { return &self; }
5027 const LDKOnionMessageProvider* operator &() const { return &self; }
5028 const LDKOnionMessageProvider* operator ->() const { return &self; }
5030 * Gets the next pending onion message for the peer with the given node id.
5032 * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
5034 inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
5036 class EventsProvider {
5038 LDKEventsProvider self;
5040 EventsProvider(const EventsProvider&) = delete;
5041 EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
5042 EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
5043 operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
5044 ~EventsProvider() { EventsProvider_free(self); }
5045 EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
5046 LDKEventsProvider* operator &() { return &self; }
5047 LDKEventsProvider* operator ->() { return &self; }
5048 const LDKEventsProvider* operator &() const { return &self; }
5049 const LDKEventsProvider* operator ->() const { return &self; }
5051 * Processes any events generated since the last call using the given event handler.
5053 * See the trait-level documentation for requirements.
5055 inline void process_pending_events(struct LDKEventHandler handler);
5057 class EventHandler {
5059 LDKEventHandler self;
5061 EventHandler(const EventHandler&) = delete;
5062 EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
5063 EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
5064 operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
5065 ~EventHandler() { EventHandler_free(self); }
5066 EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
5067 LDKEventHandler* operator &() { return &self; }
5068 LDKEventHandler* operator ->() { return &self; }
5069 const LDKEventHandler* operator &() const { return &self; }
5070 const LDKEventHandler* operator ->() const { return &self; }
5072 * Handles the given [`Event`].
5074 * See [`EventsProvider`] for details that must be considered when implementing this method.
5076 inline void handle_event(struct LDKEvent event);
5078 class Bolt11ParseError {
5080 LDKBolt11ParseError self;
5082 Bolt11ParseError(const Bolt11ParseError&) = delete;
5083 Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
5084 Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
5085 operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
5086 ~Bolt11ParseError() { Bolt11ParseError_free(self); }
5087 Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
5088 LDKBolt11ParseError* operator &() { return &self; }
5089 LDKBolt11ParseError* operator ->() { return &self; }
5090 const LDKBolt11ParseError* operator &() const { return &self; }
5091 const LDKBolt11ParseError* operator ->() const { return &self; }
5093 class ParseOrSemanticError {
5095 LDKParseOrSemanticError self;
5097 ParseOrSemanticError(const ParseOrSemanticError&) = delete;
5098 ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
5099 ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
5100 operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
5101 ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
5102 ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
5103 LDKParseOrSemanticError* operator &() { return &self; }
5104 LDKParseOrSemanticError* operator ->() { return &self; }
5105 const LDKParseOrSemanticError* operator &() const { return &self; }
5106 const LDKParseOrSemanticError* operator ->() const { return &self; }
5108 class Bolt11Invoice {
5110 LDKBolt11Invoice self;
5112 Bolt11Invoice(const Bolt11Invoice&) = delete;
5113 Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
5114 Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
5115 operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
5116 ~Bolt11Invoice() { Bolt11Invoice_free(self); }
5117 Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
5118 LDKBolt11Invoice* operator &() { return &self; }
5119 LDKBolt11Invoice* operator ->() { return &self; }
5120 const LDKBolt11Invoice* operator &() const { return &self; }
5121 const LDKBolt11Invoice* operator ->() const { return &self; }
5123 class SignedRawBolt11Invoice {
5125 LDKSignedRawBolt11Invoice self;
5127 SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
5128 SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
5129 SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
5130 operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
5131 ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
5132 SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
5133 LDKSignedRawBolt11Invoice* operator &() { return &self; }
5134 LDKSignedRawBolt11Invoice* operator ->() { return &self; }
5135 const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
5136 const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
5138 class RawBolt11Invoice {
5140 LDKRawBolt11Invoice self;
5142 RawBolt11Invoice(const RawBolt11Invoice&) = delete;
5143 RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
5144 RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
5145 operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
5146 ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
5147 RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
5148 LDKRawBolt11Invoice* operator &() { return &self; }
5149 LDKRawBolt11Invoice* operator ->() { return &self; }
5150 const LDKRawBolt11Invoice* operator &() const { return &self; }
5151 const LDKRawBolt11Invoice* operator ->() const { return &self; }
5155 LDKRawDataPart self;
5157 RawDataPart(const RawDataPart&) = delete;
5158 RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
5159 RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
5160 operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
5161 ~RawDataPart() { RawDataPart_free(self); }
5162 RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
5163 LDKRawDataPart* operator &() { return &self; }
5164 LDKRawDataPart* operator ->() { return &self; }
5165 const LDKRawDataPart* operator &() const { return &self; }
5166 const LDKRawDataPart* operator ->() const { return &self; }
5168 class PositiveTimestamp {
5170 LDKPositiveTimestamp self;
5172 PositiveTimestamp(const PositiveTimestamp&) = delete;
5173 PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
5174 PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
5175 operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
5176 ~PositiveTimestamp() { PositiveTimestamp_free(self); }
5177 PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
5178 LDKPositiveTimestamp* operator &() { return &self; }
5179 LDKPositiveTimestamp* operator ->() { return &self; }
5180 const LDKPositiveTimestamp* operator &() const { return &self; }
5181 const LDKPositiveTimestamp* operator ->() const { return &self; }
5187 SiPrefix(const SiPrefix&) = delete;
5188 SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
5189 SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
5190 operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
5191 SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
5192 LDKSiPrefix* operator &() { return &self; }
5193 LDKSiPrefix* operator ->() { return &self; }
5194 const LDKSiPrefix* operator &() const { return &self; }
5195 const LDKSiPrefix* operator ->() const { return &self; }
5201 Currency(const Currency&) = delete;
5202 Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
5203 Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
5204 operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
5205 Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
5206 LDKCurrency* operator &() { return &self; }
5207 LDKCurrency* operator ->() { return &self; }
5208 const LDKCurrency* operator &() const { return &self; }
5209 const LDKCurrency* operator ->() const { return &self; }
5215 Sha256(const Sha256&) = delete;
5216 Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
5217 Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
5218 operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
5219 ~Sha256() { Sha256_free(self); }
5220 Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
5221 LDKSha256* operator &() { return &self; }
5222 LDKSha256* operator ->() { return &self; }
5223 const LDKSha256* operator &() const { return &self; }
5224 const LDKSha256* operator ->() const { return &self; }
5228 LDKDescription self;
5230 Description(const Description&) = delete;
5231 Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
5232 Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
5233 operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
5234 ~Description() { Description_free(self); }
5235 Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
5236 LDKDescription* operator &() { return &self; }
5237 LDKDescription* operator ->() { return &self; }
5238 const LDKDescription* operator &() const { return &self; }
5239 const LDKDescription* operator ->() const { return &self; }
5243 LDKPayeePubKey self;
5245 PayeePubKey(const PayeePubKey&) = delete;
5246 PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
5247 PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
5248 operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
5249 ~PayeePubKey() { PayeePubKey_free(self); }
5250 PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
5251 LDKPayeePubKey* operator &() { return &self; }
5252 LDKPayeePubKey* operator ->() { return &self; }
5253 const LDKPayeePubKey* operator &() const { return &self; }
5254 const LDKPayeePubKey* operator ->() const { return &self; }
5260 ExpiryTime(const ExpiryTime&) = delete;
5261 ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
5262 ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
5263 operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
5264 ~ExpiryTime() { ExpiryTime_free(self); }
5265 ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
5266 LDKExpiryTime* operator &() { return &self; }
5267 LDKExpiryTime* operator ->() { return &self; }
5268 const LDKExpiryTime* operator &() const { return &self; }
5269 const LDKExpiryTime* operator ->() const { return &self; }
5271 class MinFinalCltvExpiryDelta {
5273 LDKMinFinalCltvExpiryDelta self;
5275 MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
5276 MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
5277 MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
5278 operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
5279 ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
5280 MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
5281 LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
5282 LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
5283 const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
5284 const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
5290 Fallback(const Fallback&) = delete;
5291 Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
5292 Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
5293 operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
5294 ~Fallback() { Fallback_free(self); }
5295 Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
5296 LDKFallback* operator &() { return &self; }
5297 LDKFallback* operator ->() { return &self; }
5298 const LDKFallback* operator &() const { return &self; }
5299 const LDKFallback* operator ->() const { return &self; }
5301 class Bolt11InvoiceSignature {
5303 LDKBolt11InvoiceSignature self;
5305 Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
5306 Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
5307 Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
5308 operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
5309 ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
5310 Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
5311 LDKBolt11InvoiceSignature* operator &() { return &self; }
5312 LDKBolt11InvoiceSignature* operator ->() { return &self; }
5313 const LDKBolt11InvoiceSignature* operator &() const { return &self; }
5314 const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
5316 class PrivateRoute {
5318 LDKPrivateRoute self;
5320 PrivateRoute(const PrivateRoute&) = delete;
5321 PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
5322 PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
5323 operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
5324 ~PrivateRoute() { PrivateRoute_free(self); }
5325 PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
5326 LDKPrivateRoute* operator &() { return &self; }
5327 LDKPrivateRoute* operator ->() { return &self; }
5328 const LDKPrivateRoute* operator &() const { return &self; }
5329 const LDKPrivateRoute* operator ->() const { return &self; }
5331 class CreationError {
5333 LDKCreationError self;
5335 CreationError(const CreationError&) = delete;
5336 CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
5337 CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
5338 operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
5339 CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
5340 LDKCreationError* operator &() { return &self; }
5341 LDKCreationError* operator ->() { return &self; }
5342 const LDKCreationError* operator &() const { return &self; }
5343 const LDKCreationError* operator ->() const { return &self; }
5345 class Bolt11SemanticError {
5347 LDKBolt11SemanticError self;
5349 Bolt11SemanticError(const Bolt11SemanticError&) = delete;
5350 Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
5351 Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
5352 operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
5353 Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
5354 LDKBolt11SemanticError* operator &() { return &self; }
5355 LDKBolt11SemanticError* operator ->() { return &self; }
5356 const LDKBolt11SemanticError* operator &() const { return &self; }
5357 const LDKBolt11SemanticError* operator ->() const { return &self; }
5359 class SignOrCreationError {
5361 LDKSignOrCreationError self;
5363 SignOrCreationError(const SignOrCreationError&) = delete;
5364 SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
5365 SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
5366 operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
5367 ~SignOrCreationError() { SignOrCreationError_free(self); }
5368 SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
5369 LDKSignOrCreationError* operator &() { return &self; }
5370 LDKSignOrCreationError* operator ->() { return &self; }
5371 const LDKSignOrCreationError* operator &() const { return &self; }
5372 const LDKSignOrCreationError* operator ->() const { return &self; }
5378 OutPoint(const OutPoint&) = delete;
5379 OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
5380 OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
5381 operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
5382 ~OutPoint() { OutPoint_free(self); }
5383 OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
5384 LDKOutPoint* operator &() { return &self; }
5385 LDKOutPoint* operator ->() { return &self; }
5386 const LDKOutPoint* operator &() const { return &self; }
5387 const LDKOutPoint* operator ->() const { return &self; }
5393 BigSize(const BigSize&) = delete;
5394 BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
5395 BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
5396 operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
5397 ~BigSize() { BigSize_free(self); }
5398 BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
5399 LDKBigSize* operator &() { return &self; }
5400 LDKBigSize* operator ->() { return &self; }
5401 const LDKBigSize* operator &() const { return &self; }
5402 const LDKBigSize* operator ->() const { return &self; }
5408 Hostname(const Hostname&) = delete;
5409 Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
5410 Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
5411 operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
5412 ~Hostname() { Hostname_free(self); }
5413 Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
5414 LDKHostname* operator &() { return &self; }
5415 LDKHostname* operator ->() { return &self; }
5416 const LDKHostname* operator &() const { return &self; }
5417 const LDKHostname* operator ->() const { return &self; }
5419 class TransactionU16LenLimited {
5421 LDKTransactionU16LenLimited self;
5423 TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
5424 TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
5425 TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
5426 operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
5427 ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
5428 TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
5429 LDKTransactionU16LenLimited* operator &() { return &self; }
5430 LDKTransactionU16LenLimited* operator ->() { return &self; }
5431 const LDKTransactionU16LenLimited* operator &() const { return &self; }
5432 const LDKTransactionU16LenLimited* operator ->() const { return &self; }
5434 class UntrustedString {
5436 LDKUntrustedString self;
5438 UntrustedString(const UntrustedString&) = delete;
5439 UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
5440 UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
5441 operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
5442 ~UntrustedString() { UntrustedString_free(self); }
5443 UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
5444 LDKUntrustedString* operator &() { return &self; }
5445 LDKUntrustedString* operator ->() { return &self; }
5446 const LDKUntrustedString* operator &() const { return &self; }
5447 const LDKUntrustedString* operator ->() const { return &self; }
5449 class PrintableString {
5451 LDKPrintableString self;
5453 PrintableString(const PrintableString&) = delete;
5454 PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
5455 PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
5456 operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
5457 ~PrintableString() { PrintableString_free(self); }
5458 PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
5459 LDKPrintableString* operator &() { return &self; }
5460 LDKPrintableString* operator ->() { return &self; }
5461 const LDKPrintableString* operator &() const { return &self; }
5462 const LDKPrintableString* operator ->() const { return &self; }
5464 class CustomMessageReader {
5466 LDKCustomMessageReader self;
5468 CustomMessageReader(const CustomMessageReader&) = delete;
5469 CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
5470 CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
5471 operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
5472 ~CustomMessageReader() { CustomMessageReader_free(self); }
5473 CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
5474 LDKCustomMessageReader* operator &() { return &self; }
5475 LDKCustomMessageReader* operator ->() { return &self; }
5476 const LDKCustomMessageReader* operator &() const { return &self; }
5477 const LDKCustomMessageReader* operator ->() const { return &self; }
5479 * Decodes a custom message to `CustomMessageType`. If the given message type is known to the
5480 * implementation and the message could be decoded, must return `Ok(Some(message))`. If the
5481 * message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
5482 * occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
5484 inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
5490 Type(const Type&) = delete;
5491 Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
5492 Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
5493 operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
5494 ~Type() { Type_free(self); }
5495 Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
5496 LDKType* operator &() { return &self; }
5497 LDKType* operator ->() { return &self; }
5498 const LDKType* operator &() const { return &self; }
5499 const LDKType* operator ->() const { return &self; }
5501 * Returns the type identifying the message payload.
5503 inline uint16_t type_id();
5505 * Return a human-readable "debug" string describing this object
5507 inline LDK::Str debug_str();
5511 LDKForwardNode self;
5513 ForwardNode(const ForwardNode&) = delete;
5514 ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
5515 ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
5516 operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
5517 ~ForwardNode() { ForwardNode_free(self); }
5518 ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
5519 LDKForwardNode* operator &() { return &self; }
5520 LDKForwardNode* operator ->() { return &self; }
5521 const LDKForwardNode* operator &() const { return &self; }
5522 const LDKForwardNode* operator ->() const { return &self; }
5526 LDKForwardTlvs self;
5528 ForwardTlvs(const ForwardTlvs&) = delete;
5529 ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
5530 ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
5531 operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
5532 ~ForwardTlvs() { ForwardTlvs_free(self); }
5533 ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
5534 LDKForwardTlvs* operator &() { return &self; }
5535 LDKForwardTlvs* operator ->() { return &self; }
5536 const LDKForwardTlvs* operator &() const { return &self; }
5537 const LDKForwardTlvs* operator ->() const { return &self; }
5541 LDKReceiveTlvs self;
5543 ReceiveTlvs(const ReceiveTlvs&) = delete;
5544 ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
5545 ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
5546 operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
5547 ~ReceiveTlvs() { ReceiveTlvs_free(self); }
5548 ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
5549 LDKReceiveTlvs* operator &() { return &self; }
5550 LDKReceiveTlvs* operator ->() { return &self; }
5551 const LDKReceiveTlvs* operator &() const { return &self; }
5552 const LDKReceiveTlvs* operator ->() const { return &self; }
5554 class PaymentRelay {
5556 LDKPaymentRelay self;
5558 PaymentRelay(const PaymentRelay&) = delete;
5559 PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
5560 PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
5561 operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
5562 ~PaymentRelay() { PaymentRelay_free(self); }
5563 PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
5564 LDKPaymentRelay* operator &() { return &self; }
5565 LDKPaymentRelay* operator ->() { return &self; }
5566 const LDKPaymentRelay* operator &() const { return &self; }
5567 const LDKPaymentRelay* operator ->() const { return &self; }
5569 class PaymentConstraints {
5571 LDKPaymentConstraints self;
5573 PaymentConstraints(const PaymentConstraints&) = delete;
5574 PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
5575 PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
5576 operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
5577 ~PaymentConstraints() { PaymentConstraints_free(self); }
5578 PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
5579 LDKPaymentConstraints* operator &() { return &self; }
5580 LDKPaymentConstraints* operator ->() { return &self; }
5581 const LDKPaymentConstraints* operator &() const { return &self; }
5582 const LDKPaymentConstraints* operator ->() const { return &self; }
5584 class PaymentError {
5586 LDKPaymentError self;
5588 PaymentError(const PaymentError&) = delete;
5589 PaymentError(PaymentError&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentError)); }
5590 PaymentError(LDKPaymentError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentError)); }
5591 operator LDKPaymentError() && { LDKPaymentError res = self; memset(&self, 0, sizeof(LDKPaymentError)); return res; }
5592 ~PaymentError() { PaymentError_free(self); }
5593 PaymentError& operator=(PaymentError&& o) { PaymentError_free(self); self = o.self; memset(&o, 0, sizeof(PaymentError)); return *this; }
5594 LDKPaymentError* operator &() { return &self; }
5595 LDKPaymentError* operator ->() { return &self; }
5596 const LDKPaymentError* operator &() const { return &self; }
5597 const LDKPaymentError* operator ->() const { return &self; }
5599 class ProbingError {
5601 LDKProbingError self;
5603 ProbingError(const ProbingError&) = delete;
5604 ProbingError(ProbingError&& o) : self(o.self) { memset(&o, 0, sizeof(ProbingError)); }
5605 ProbingError(LDKProbingError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbingError)); }
5606 operator LDKProbingError() && { LDKProbingError res = self; memset(&self, 0, sizeof(LDKProbingError)); return res; }
5607 ~ProbingError() { ProbingError_free(self); }
5608 ProbingError& operator=(ProbingError&& o) { ProbingError_free(self); self = o.self; memset(&o, 0, sizeof(ProbingError)); return *this; }
5609 LDKProbingError* operator &() { return &self; }
5610 LDKProbingError* operator ->() { return &self; }
5611 const LDKProbingError* operator &() const { return &self; }
5612 const LDKProbingError* operator ->() const { return &self; }
5614 class UtxoLookupError {
5616 LDKUtxoLookupError self;
5618 UtxoLookupError(const UtxoLookupError&) = delete;
5619 UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
5620 UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
5621 operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
5622 UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
5623 LDKUtxoLookupError* operator &() { return &self; }
5624 LDKUtxoLookupError* operator ->() { return &self; }
5625 const LDKUtxoLookupError* operator &() const { return &self; }
5626 const LDKUtxoLookupError* operator ->() const { return &self; }
5632 UtxoResult(const UtxoResult&) = delete;
5633 UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
5634 UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
5635 operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
5636 ~UtxoResult() { UtxoResult_free(self); }
5637 UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
5638 LDKUtxoResult* operator &() { return &self; }
5639 LDKUtxoResult* operator ->() { return &self; }
5640 const LDKUtxoResult* operator &() const { return &self; }
5641 const LDKUtxoResult* operator ->() const { return &self; }
5647 UtxoLookup(const UtxoLookup&) = delete;
5648 UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
5649 UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
5650 operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
5651 ~UtxoLookup() { UtxoLookup_free(self); }
5652 UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
5653 LDKUtxoLookup* operator &() { return &self; }
5654 LDKUtxoLookup* operator ->() { return &self; }
5655 const LDKUtxoLookup* operator &() const { return &self; }
5656 const LDKUtxoLookup* operator ->() const { return &self; }
5658 * Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
5659 * Returns an error if `genesis_hash` is for a different chain or if such a transaction output
5662 * [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
5664 inline LDK::UtxoResult get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id);
5670 UtxoFuture(const UtxoFuture&) = delete;
5671 UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
5672 UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
5673 operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
5674 ~UtxoFuture() { UtxoFuture_free(self); }
5675 UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
5676 LDKUtxoFuture* operator &() { return &self; }
5677 LDKUtxoFuture* operator ->() { return &self; }
5678 const LDKUtxoFuture* operator &() const { return &self; }
5679 const LDKUtxoFuture* operator ->() const { return &self; }
5681 class OnionMessenger {
5683 LDKOnionMessenger self;
5685 OnionMessenger(const OnionMessenger&) = delete;
5686 OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
5687 OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
5688 operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
5689 ~OnionMessenger() { OnionMessenger_free(self); }
5690 OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
5691 LDKOnionMessenger* operator &() { return &self; }
5692 LDKOnionMessenger* operator ->() { return &self; }
5693 const LDKOnionMessenger* operator &() const { return &self; }
5694 const LDKOnionMessenger* operator ->() const { return &self; }
5696 class MessageRouter {
5698 LDKMessageRouter self;
5700 MessageRouter(const MessageRouter&) = delete;
5701 MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
5702 MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
5703 operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
5704 ~MessageRouter() { MessageRouter_free(self); }
5705 MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
5706 LDKMessageRouter* operator &() { return &self; }
5707 LDKMessageRouter* operator ->() { return &self; }
5708 const LDKMessageRouter* operator &() const { return &self; }
5709 const LDKMessageRouter* operator ->() const { return &self; }
5711 * Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
5713 * [`OnionMessage`]: msgs::OnionMessage
5715 inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
5717 class DefaultMessageRouter {
5719 LDKDefaultMessageRouter self;
5721 DefaultMessageRouter(const DefaultMessageRouter&) = delete;
5722 DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
5723 DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
5724 operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
5725 ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
5726 DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
5727 LDKDefaultMessageRouter* operator &() { return &self; }
5728 LDKDefaultMessageRouter* operator ->() { return &self; }
5729 const LDKDefaultMessageRouter* operator &() const { return &self; }
5730 const LDKDefaultMessageRouter* operator ->() const { return &self; }
5732 class OnionMessagePath {
5734 LDKOnionMessagePath self;
5736 OnionMessagePath(const OnionMessagePath&) = delete;
5737 OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
5738 OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
5739 operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
5740 ~OnionMessagePath() { OnionMessagePath_free(self); }
5741 OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
5742 LDKOnionMessagePath* operator &() { return &self; }
5743 LDKOnionMessagePath* operator ->() { return &self; }
5744 const LDKOnionMessagePath* operator &() const { return &self; }
5745 const LDKOnionMessagePath* operator ->() const { return &self; }
5749 LDKDestination self;
5751 Destination(const Destination&) = delete;
5752 Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
5753 Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
5754 operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
5755 ~Destination() { Destination_free(self); }
5756 Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
5757 LDKDestination* operator &() { return &self; }
5758 LDKDestination* operator ->() { return &self; }
5759 const LDKDestination* operator &() const { return &self; }
5760 const LDKDestination* operator ->() const { return &self; }
5766 SendError(const SendError&) = delete;
5767 SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
5768 SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
5769 operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
5770 ~SendError() { SendError_free(self); }
5771 SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
5772 LDKSendError* operator &() { return &self; }
5773 LDKSendError* operator ->() { return &self; }
5774 const LDKSendError* operator &() const { return &self; }
5775 const LDKSendError* operator ->() const { return &self; }
5777 class CustomOnionMessageHandler {
5779 LDKCustomOnionMessageHandler self;
5781 CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
5782 CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
5783 CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
5784 operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
5785 ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
5786 CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
5787 LDKCustomOnionMessageHandler* operator &() { return &self; }
5788 LDKCustomOnionMessageHandler* operator ->() { return &self; }
5789 const LDKCustomOnionMessageHandler* operator &() const { return &self; }
5790 const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
5792 * Called with the custom message that was received, returning a response to send, if any.
5794 inline LDK::COption_CustomOnionMessageContentsZ handle_custom_message(struct LDKCustomOnionMessageContents msg);
5796 * Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
5797 * message type is unknown.
5799 inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
5801 class FilesystemStore {
5803 LDKFilesystemStore self;
5805 FilesystemStore(const FilesystemStore&) = delete;
5806 FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
5807 FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
5808 operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
5809 ~FilesystemStore() { FilesystemStore_free(self); }
5810 FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
5811 LDKFilesystemStore* operator &() { return &self; }
5812 LDKFilesystemStore* operator ->() { return &self; }
5813 const LDKFilesystemStore* operator &() const { return &self; }
5814 const LDKFilesystemStore* operator ->() const { return &self; }
5818 LDKBlindedPath self;
5820 BlindedPath(const BlindedPath&) = delete;
5821 BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
5822 BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
5823 operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
5824 ~BlindedPath() { BlindedPath_free(self); }
5825 BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
5826 LDKBlindedPath* operator &() { return &self; }
5827 LDKBlindedPath* operator ->() { return &self; }
5828 const LDKBlindedPath* operator &() const { return &self; }
5829 const LDKBlindedPath* operator ->() const { return &self; }
5835 BlindedHop(const BlindedHop&) = delete;
5836 BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
5837 BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
5838 operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
5839 ~BlindedHop() { BlindedHop_free(self); }
5840 BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
5841 LDKBlindedHop* operator &() { return &self; }
5842 LDKBlindedHop* operator ->() { return &self; }
5843 const LDKBlindedHop* operator &() const { return &self; }
5844 const LDKBlindedHop* operator ->() const { return &self; }
5846 class GraphSyncError {
5848 LDKGraphSyncError self;
5850 GraphSyncError(const GraphSyncError&) = delete;
5851 GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
5852 GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
5853 operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
5854 ~GraphSyncError() { GraphSyncError_free(self); }
5855 GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
5856 LDKGraphSyncError* operator &() { return &self; }
5857 LDKGraphSyncError* operator ->() { return &self; }
5858 const LDKGraphSyncError* operator &() const { return &self; }
5859 const LDKGraphSyncError* operator ->() const { return &self; }
5861 class InvoiceError {
5863 LDKInvoiceError self;
5865 InvoiceError(const InvoiceError&) = delete;
5866 InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
5867 InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
5868 operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
5869 ~InvoiceError() { InvoiceError_free(self); }
5870 InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
5871 LDKInvoiceError* operator &() { return &self; }
5872 LDKInvoiceError* operator ->() { return &self; }
5873 const LDKInvoiceError* operator &() const { return &self; }
5874 const LDKInvoiceError* operator ->() const { return &self; }
5876 class ErroneousField {
5878 LDKErroneousField self;
5880 ErroneousField(const ErroneousField&) = delete;
5881 ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
5882 ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
5883 operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
5884 ~ErroneousField() { ErroneousField_free(self); }
5885 ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
5886 LDKErroneousField* operator &() { return &self; }
5887 LDKErroneousField* operator ->() { return &self; }
5888 const LDKErroneousField* operator &() const { return &self; }
5889 const LDKErroneousField* operator ->() const { return &self; }
5891 class MonitorUpdateId {
5893 LDKMonitorUpdateId self;
5895 MonitorUpdateId(const MonitorUpdateId&) = delete;
5896 MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
5897 MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
5898 operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
5899 ~MonitorUpdateId() { MonitorUpdateId_free(self); }
5900 MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
5901 LDKMonitorUpdateId* operator &() { return &self; }
5902 LDKMonitorUpdateId* operator ->() { return &self; }
5903 const LDKMonitorUpdateId* operator &() const { return &self; }
5904 const LDKMonitorUpdateId* operator ->() const { return &self; }
5910 Persist(const Persist&) = delete;
5911 Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
5912 Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
5913 operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
5914 ~Persist() { Persist_free(self); }
5915 Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
5916 LDKPersist* operator &() { return &self; }
5917 LDKPersist* operator ->() { return &self; }
5918 const LDKPersist* operator &() const { return &self; }
5919 const LDKPersist* operator ->() const { return &self; }
5921 * Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
5922 * called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
5924 * The data can be stored any way you want, but the identifier provided by LDK is the
5925 * channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
5926 * and the stored channel data). Note that you **must** persist every new monitor to disk.
5928 * The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
5929 * if you return [`ChannelMonitorUpdateStatus::InProgress`].
5931 * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
5932 * and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
5934 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
5935 * [`Writeable::write`]: crate::util::ser::Writeable::write
5937 inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
5939 * Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
5942 * Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
5943 * updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
5946 * During blockchain synchronization operations, and in some rare cases, this may be called with
5947 * no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
5948 * Note that after the full [`ChannelMonitor`] is persisted any previous
5949 * [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
5950 * applied to the persisted [`ChannelMonitor`] as they were already applied.
5952 * If an implementer chooses to persist the updates only, they need to make
5953 * sure that all the updates are applied to the `ChannelMonitors` *before*
5954 * the set of channel monitors is given to the `ChannelManager`
5955 * deserialization routine. See [`ChannelMonitor::update_monitor`] for
5956 * applying a monitor update to a monitor. If full `ChannelMonitors` are
5957 * persisted, then there is no need to persist individual updates.
5959 * Note that there could be a performance tradeoff between persisting complete
5960 * channel monitors on every update vs. persisting only updates and applying
5961 * them in batches. The size of each monitor grows `O(number of state updates)`
5962 * whereas updates are small and `O(1)`.
5964 * The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
5965 * if you return [`ChannelMonitorUpdateStatus::InProgress`].
5967 * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
5968 * [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
5969 * [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
5971 * [`Writeable::write`]: crate::util::ser::Writeable::write
5973 * Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
5975 inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
5977 class LockedChannelMonitor {
5979 LDKLockedChannelMonitor self;
5981 LockedChannelMonitor(const LockedChannelMonitor&) = delete;
5982 LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
5983 LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
5984 operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
5985 ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
5986 LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
5987 LDKLockedChannelMonitor* operator &() { return &self; }
5988 LDKLockedChannelMonitor* operator ->() { return &self; }
5989 const LDKLockedChannelMonitor* operator &() const { return &self; }
5990 const LDKLockedChannelMonitor* operator ->() const { return &self; }
5992 class ChainMonitor {
5994 LDKChainMonitor self;
5996 ChainMonitor(const ChainMonitor&) = delete;
5997 ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
5998 ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
5999 operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
6000 ~ChainMonitor() { ChainMonitor_free(self); }
6001 ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
6002 LDKChainMonitor* operator &() { return &self; }
6003 LDKChainMonitor* operator ->() { return &self; }
6004 const LDKChainMonitor* operator &() const { return &self; }
6005 const LDKChainMonitor* operator ->() const { return &self; }
6007 class CResult_LockedChannelMonitorNoneZ {
6009 LDKCResult_LockedChannelMonitorNoneZ self;
6011 CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
6012 CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
6013 CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
6014 operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
6015 ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
6016 CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
6017 LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
6018 LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
6019 const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
6020 const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
6022 class CResult_TransactionU16LenLimitedNoneZ {
6024 LDKCResult_TransactionU16LenLimitedNoneZ self;
6026 CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
6027 CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
6028 CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
6029 operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
6030 ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
6031 CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
6032 LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
6033 LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
6034 const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
6035 const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
6037 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
6039 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
6041 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
6042 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6043 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6044 operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
6045 ~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
6046 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ& operator=(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return *this; }
6047 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
6048 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
6049 const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
6050 const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
6052 class CResult_PhantomRouteHintsDecodeErrorZ {
6054 LDKCResult_PhantomRouteHintsDecodeErrorZ self;
6056 CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
6057 CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
6058 CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
6059 operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
6060 ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
6061 CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
6062 LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
6063 LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
6064 const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
6065 const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
6067 class CResult_FundingCreatedDecodeErrorZ {
6069 LDKCResult_FundingCreatedDecodeErrorZ self;
6071 CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
6072 CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
6073 CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
6074 operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
6075 ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
6076 CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
6077 LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
6078 LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
6079 const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
6080 const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
6082 class CVec_C2Tuple_u32TxOutZZ {
6084 LDKCVec_C2Tuple_u32TxOutZZ self;
6086 CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
6087 CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
6088 CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
6089 operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
6090 ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
6091 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; }
6092 LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
6093 LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
6094 const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
6095 const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
6097 class CResult_RetryDecodeErrorZ {
6099 LDKCResult_RetryDecodeErrorZ self;
6101 CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
6102 CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
6103 CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
6104 operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
6105 ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
6106 CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
6107 LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
6108 LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
6109 const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
6110 const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
6112 class CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ {
6114 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ self;
6116 CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(const CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&) = delete;
6117 CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
6118 CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); }
6119 operator LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() && { LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return res; }
6120 ~CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ() { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); }
6121 CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ& operator=(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ&& o) { CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ)); return *this; }
6122 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() { return &self; }
6123 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() { return &self; }
6124 const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator &() const { return &self; }
6125 const LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* operator ->() const { return &self; }
6127 class CResult_ChannelInfoDecodeErrorZ {
6129 LDKCResult_ChannelInfoDecodeErrorZ self;
6131 CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
6132 CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
6133 CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
6134 operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
6135 ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
6136 CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
6137 LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
6138 LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
6139 const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
6140 const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
6142 class COption_MaxDustHTLCExposureZ {
6144 LDKCOption_MaxDustHTLCExposureZ self;
6146 COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
6147 COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
6148 COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
6149 operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
6150 ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
6151 COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
6152 LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
6153 LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
6154 const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
6155 const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
6157 class CResult_NoneSendErrorZ {
6159 LDKCResult_NoneSendErrorZ self;
6161 CResult_NoneSendErrorZ(const CResult_NoneSendErrorZ&) = delete;
6162 CResult_NoneSendErrorZ(CResult_NoneSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); }
6163 CResult_NoneSendErrorZ(LDKCResult_NoneSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneSendErrorZ)); }
6164 operator LDKCResult_NoneSendErrorZ() && { LDKCResult_NoneSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneSendErrorZ)); return res; }
6165 ~CResult_NoneSendErrorZ() { CResult_NoneSendErrorZ_free(self); }
6166 CResult_NoneSendErrorZ& operator=(CResult_NoneSendErrorZ&& o) { CResult_NoneSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneSendErrorZ)); return *this; }
6167 LDKCResult_NoneSendErrorZ* operator &() { return &self; }
6168 LDKCResult_NoneSendErrorZ* operator ->() { return &self; }
6169 const LDKCResult_NoneSendErrorZ* operator &() const { return &self; }
6170 const LDKCResult_NoneSendErrorZ* operator ->() const { return &self; }
6172 class C2Tuple_CVec_u8ZusizeZ {
6174 LDKC2Tuple_CVec_u8ZusizeZ self;
6176 C2Tuple_CVec_u8ZusizeZ(const C2Tuple_CVec_u8ZusizeZ&) = delete;
6177 C2Tuple_CVec_u8ZusizeZ(C2Tuple_CVec_u8ZusizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); }
6178 C2Tuple_CVec_u8ZusizeZ(LDKC2Tuple_CVec_u8ZusizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); }
6179 operator LDKC2Tuple_CVec_u8ZusizeZ() && { LDKC2Tuple_CVec_u8ZusizeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8ZusizeZ)); return res; }
6180 ~C2Tuple_CVec_u8ZusizeZ() { C2Tuple_CVec_u8ZusizeZ_free(self); }
6181 C2Tuple_CVec_u8ZusizeZ& operator=(C2Tuple_CVec_u8ZusizeZ&& o) { C2Tuple_CVec_u8ZusizeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8ZusizeZ)); return *this; }
6182 LDKC2Tuple_CVec_u8ZusizeZ* operator &() { return &self; }
6183 LDKC2Tuple_CVec_u8ZusizeZ* operator ->() { return &self; }
6184 const LDKC2Tuple_CVec_u8ZusizeZ* operator &() const { return &self; }
6185 const LDKC2Tuple_CVec_u8ZusizeZ* operator ->() const { return &self; }
6187 class COption_OffersMessageZ {
6189 LDKCOption_OffersMessageZ self;
6191 COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
6192 COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
6193 COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
6194 operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
6195 ~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
6196 COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
6197 LDKCOption_OffersMessageZ* operator &() { return &self; }
6198 LDKCOption_OffersMessageZ* operator ->() { return &self; }
6199 const LDKCOption_OffersMessageZ* operator &() const { return &self; }
6200 const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
6202 class COption_NetworkUpdateZ {
6204 LDKCOption_NetworkUpdateZ self;
6206 COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
6207 COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
6208 COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
6209 operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
6210 ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
6211 COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
6212 LDKCOption_NetworkUpdateZ* operator &() { return &self; }
6213 LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
6214 const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
6215 const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
6217 class COption_u64Z {
6219 LDKCOption_u64Z self;
6221 COption_u64Z(const COption_u64Z&) = delete;
6222 COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
6223 COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
6224 operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
6225 ~COption_u64Z() { COption_u64Z_free(self); }
6226 COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
6227 LDKCOption_u64Z* operator &() { return &self; }
6228 LDKCOption_u64Z* operator ->() { return &self; }
6229 const LDKCOption_u64Z* operator &() const { return &self; }
6230 const LDKCOption_u64Z* operator ->() const { return &self; }
6232 class CResult_CVec_u8ZPeerHandleErrorZ {
6234 LDKCResult_CVec_u8ZPeerHandleErrorZ self;
6236 CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
6237 CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
6238 CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
6239 operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
6240 ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
6241 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; }
6242 LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
6243 LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
6244 const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
6245 const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
6247 class CResult_GossipTimestampFilterDecodeErrorZ {
6249 LDKCResult_GossipTimestampFilterDecodeErrorZ self;
6251 CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
6252 CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
6253 CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
6254 operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
6255 ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
6256 CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
6257 LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
6258 LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
6259 const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
6260 const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
6262 class CResult_RouteHintDecodeErrorZ {
6264 LDKCResult_RouteHintDecodeErrorZ self;
6266 CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
6267 CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
6268 CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
6269 operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
6270 ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
6271 CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
6272 LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
6273 LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
6274 const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
6275 const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
6277 class COption_FilterZ {
6279 LDKCOption_FilterZ self;
6281 COption_FilterZ(const COption_FilterZ&) = delete;
6282 COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
6283 COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
6284 operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
6285 ~COption_FilterZ() { COption_FilterZ_free(self); }
6286 COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
6287 LDKCOption_FilterZ* operator &() { return &self; }
6288 LDKCOption_FilterZ* operator ->() { return &self; }
6289 const LDKCOption_FilterZ* operator &() const { return &self; }
6290 const LDKCOption_FilterZ* operator ->() const { return &self; }
6292 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
6294 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
6296 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
6297 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
6298 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)); }
6299 operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
6300 ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
6301 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; }
6302 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
6303 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
6304 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
6305 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
6307 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
6309 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
6311 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
6312 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6313 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6314 operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
6315 ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
6316 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; }
6317 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
6318 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
6319 const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
6320 const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
6322 class CResult_COption_APIErrorZDecodeErrorZ {
6324 LDKCResult_COption_APIErrorZDecodeErrorZ self;
6326 CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
6327 CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
6328 CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
6329 operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
6330 ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
6331 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; }
6332 LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
6333 LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
6334 const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
6335 const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
6337 class CVec_UpdateAddHTLCZ {
6339 LDKCVec_UpdateAddHTLCZ self;
6341 CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
6342 CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
6343 CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
6344 operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
6345 ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
6346 CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
6347 LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
6348 LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
6349 const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
6350 const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
6352 class CResult_TxAbortDecodeErrorZ {
6354 LDKCResult_TxAbortDecodeErrorZ self;
6356 CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
6357 CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
6358 CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
6359 operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
6360 ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
6361 CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
6362 LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
6363 LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
6364 const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
6365 const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
6367 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
6369 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
6371 CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
6372 CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6373 CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6374 operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
6375 ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
6376 CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
6377 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
6378 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
6379 const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
6380 const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
6382 class COption_u32Z {
6384 LDKCOption_u32Z self;
6386 COption_u32Z(const COption_u32Z&) = delete;
6387 COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
6388 COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
6389 operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
6390 ~COption_u32Z() { COption_u32Z_free(self); }
6391 COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
6392 LDKCOption_u32Z* operator &() { return &self; }
6393 LDKCOption_u32Z* operator ->() { return &self; }
6394 const LDKCOption_u32Z* operator &() const { return &self; }
6395 const LDKCOption_u32Z* operator ->() const { return &self; }
6397 class CResult_RecipientOnionFieldsNoneZ {
6399 LDKCResult_RecipientOnionFieldsNoneZ self;
6401 CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
6402 CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
6403 CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
6404 operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
6405 ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
6406 CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
6407 LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
6408 LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
6409 const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
6410 const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
6412 class C2Tuple__u1632_u1632Z {
6414 LDKC2Tuple__u1632_u1632Z self;
6416 C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
6417 C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
6418 C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
6419 operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
6420 ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
6421 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; }
6422 LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
6423 LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
6424 const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
6425 const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
6427 class CResult_CVec_StrZIOErrorZ {
6429 LDKCResult_CVec_StrZIOErrorZ self;
6431 CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
6432 CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
6433 CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
6434 operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
6435 ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
6436 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; }
6437 LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
6438 LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
6439 const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
6440 const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
6442 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
6444 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
6446 CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
6447 CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6448 CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6449 operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
6450 ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
6451 CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
6452 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
6453 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
6454 const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
6455 const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
6457 class CResult_TransactionNoneZ {
6459 LDKCResult_TransactionNoneZ self;
6461 CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
6462 CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
6463 CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
6464 operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
6465 ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
6466 CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
6467 LDKCResult_TransactionNoneZ* operator &() { return &self; }
6468 LDKCResult_TransactionNoneZ* operator ->() { return &self; }
6469 const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
6470 const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
6472 class CResult_CommitmentSignedDecodeErrorZ {
6474 LDKCResult_CommitmentSignedDecodeErrorZ self;
6476 CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
6477 CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
6478 CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
6479 operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
6480 ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
6481 CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
6482 LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
6483 LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
6484 const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
6485 const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
6487 class CResult_CommitmentTransactionDecodeErrorZ {
6489 LDKCResult_CommitmentTransactionDecodeErrorZ self;
6491 CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
6492 CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
6493 CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
6494 operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
6495 ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
6496 CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
6497 LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
6498 LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
6499 const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
6500 const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
6502 class CResult_ErrorMessageDecodeErrorZ {
6504 LDKCResult_ErrorMessageDecodeErrorZ self;
6506 CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
6507 CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
6508 CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
6509 operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
6510 ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
6511 CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
6512 LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
6513 LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
6514 const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
6515 const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
6517 class CResult_OpenChannelDecodeErrorZ {
6519 LDKCResult_OpenChannelDecodeErrorZ self;
6521 CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
6522 CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
6523 CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
6524 operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
6525 ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
6526 CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
6527 LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
6528 LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
6529 const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
6530 const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
6532 class COption_APIErrorZ {
6534 LDKCOption_APIErrorZ self;
6536 COption_APIErrorZ(const COption_APIErrorZ&) = delete;
6537 COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
6538 COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
6539 operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
6540 ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
6541 COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
6542 LDKCOption_APIErrorZ* operator &() { return &self; }
6543 LDKCOption_APIErrorZ* operator ->() { return &self; }
6544 const LDKCOption_APIErrorZ* operator &() const { return &self; }
6545 const LDKCOption_APIErrorZ* operator ->() const { return &self; }
6547 class CResult_QueryChannelRangeDecodeErrorZ {
6549 LDKCResult_QueryChannelRangeDecodeErrorZ self;
6551 CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
6552 CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
6553 CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
6554 operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
6555 ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
6556 CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
6557 LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
6558 LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
6559 const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
6560 const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
6562 class CVec_TransactionZ {
6564 LDKCVec_TransactionZ self;
6566 CVec_TransactionZ(const CVec_TransactionZ&) = delete;
6567 CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
6568 CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
6569 operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
6570 ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
6571 CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
6572 LDKCVec_TransactionZ* operator &() { return &self; }
6573 LDKCVec_TransactionZ* operator ->() { return &self; }
6574 const LDKCVec_TransactionZ* operator &() const { return &self; }
6575 const LDKCVec_TransactionZ* operator ->() const { return &self; }
6579 LDKCVec_InputZ self;
6581 CVec_InputZ(const CVec_InputZ&) = delete;
6582 CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
6583 CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
6584 operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
6585 ~CVec_InputZ() { CVec_InputZ_free(self); }
6586 CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
6587 LDKCVec_InputZ* operator &() { return &self; }
6588 LDKCVec_InputZ* operator ->() { return &self; }
6589 const LDKCVec_InputZ* operator &() const { return &self; }
6590 const LDKCVec_InputZ* operator ->() const { return &self; }
6592 class CResult_ChannelFeaturesDecodeErrorZ {
6594 LDKCResult_ChannelFeaturesDecodeErrorZ self;
6596 CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
6597 CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
6598 CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
6599 operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
6600 ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
6601 CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
6602 LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
6603 LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
6604 const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
6605 const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
6607 class CResult_ChannelReadyDecodeErrorZ {
6609 LDKCResult_ChannelReadyDecodeErrorZ self;
6611 CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
6612 CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
6613 CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
6614 operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
6615 ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
6616 CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
6617 LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
6618 LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
6619 const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
6620 const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
6622 class CResult_UpdateFeeDecodeErrorZ {
6624 LDKCResult_UpdateFeeDecodeErrorZ self;
6626 CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
6627 CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
6628 CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
6629 operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
6630 ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
6631 CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
6632 LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
6633 LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
6634 const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
6635 const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
6637 class CResult_NoneBolt11SemanticErrorZ {
6639 LDKCResult_NoneBolt11SemanticErrorZ self;
6641 CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
6642 CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
6643 CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
6644 operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
6645 ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
6646 CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
6647 LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
6648 LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
6649 const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
6650 const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
6652 class CResult_NoneRetryableSendFailureZ {
6654 LDKCResult_NoneRetryableSendFailureZ self;
6656 CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
6657 CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
6658 CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
6659 operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
6660 ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
6661 CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
6662 LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
6663 LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
6664 const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
6665 const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
6667 class CResult_boolLightningErrorZ {
6669 LDKCResult_boolLightningErrorZ self;
6671 CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
6672 CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
6673 CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
6674 operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
6675 ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
6676 CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
6677 LDKCResult_boolLightningErrorZ* operator &() { return &self; }
6678 LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
6679 const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
6680 const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
6682 class CResult_NodeIdDecodeErrorZ {
6684 LDKCResult_NodeIdDecodeErrorZ self;
6686 CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
6687 CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
6688 CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
6689 operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
6690 ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
6691 CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
6692 LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
6693 LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
6694 const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
6695 const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
6697 class CResult_ChannelShutdownStateDecodeErrorZ {
6699 LDKCResult_ChannelShutdownStateDecodeErrorZ self;
6701 CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
6702 CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
6703 CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
6704 operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
6705 ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
6706 CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
6707 LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
6708 LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
6709 const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
6710 const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
6712 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
6714 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
6716 CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
6717 CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
6718 CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
6719 operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
6720 ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
6721 CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
6722 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
6723 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
6724 const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
6725 const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
6727 class CResult_NodeAnnouncementInfoDecodeErrorZ {
6729 LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
6731 CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
6732 CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
6733 CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
6734 operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
6735 ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
6736 CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
6737 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
6738 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
6739 const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
6740 const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
6742 class CResult_ShutdownScriptInvalidShutdownScriptZ {
6744 LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
6746 CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
6747 CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
6748 CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
6749 operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
6750 ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
6751 CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
6752 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
6753 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
6754 const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
6755 const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
6757 class CResult_COption_NetworkUpdateZDecodeErrorZ {
6759 LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
6761 CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
6762 CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
6763 CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
6764 operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
6765 ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
6766 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; }
6767 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
6768 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
6769 const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
6770 const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
6772 class CVec_UpdateFailMalformedHTLCZ {
6774 LDKCVec_UpdateFailMalformedHTLCZ self;
6776 CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
6777 CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
6778 CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
6779 operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
6780 ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
6781 CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
6782 LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
6783 LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
6784 const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
6785 const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
6787 class CResult_ShutdownScriptNoneZ {
6789 LDKCResult_ShutdownScriptNoneZ self;
6791 CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
6792 CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
6793 CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
6794 operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
6795 ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
6796 CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
6797 LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
6798 LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
6799 const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
6800 const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
6802 class COption_HTLCDestinationZ {
6804 LDKCOption_HTLCDestinationZ self;
6806 COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
6807 COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
6808 COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
6809 operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
6810 ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
6811 COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
6812 LDKCOption_HTLCDestinationZ* operator &() { return &self; }
6813 LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
6814 const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
6815 const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
6817 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
6819 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
6821 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
6822 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
6823 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
6824 operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
6825 ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
6826 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ& operator=(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return *this; }
6827 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
6828 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
6829 const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
6830 const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
6832 class CVec_RouteHopZ {
6834 LDKCVec_RouteHopZ self;
6836 CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
6837 CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
6838 CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
6839 operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
6840 ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
6841 CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
6842 LDKCVec_RouteHopZ* operator &() { return &self; }
6843 LDKCVec_RouteHopZ* operator ->() { return &self; }
6844 const LDKCVec_RouteHopZ* operator &() const { return &self; }
6845 const LDKCVec_RouteHopZ* operator ->() const { return &self; }
6847 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
6849 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
6851 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&) = delete;
6852 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
6853 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
6854 operator LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return res; }
6855 ~CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); }
6856 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return *this; }
6857 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() { return &self; }
6858 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() { return &self; }
6859 const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() const { return &self; }
6860 const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() const { return &self; }
6862 class CResult_CVec_UtxoZNoneZ {
6864 LDKCResult_CVec_UtxoZNoneZ self;
6866 CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
6867 CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
6868 CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
6869 operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
6870 ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
6871 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; }
6872 LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
6873 LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
6874 const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
6875 const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
6877 class CResult_CVec_u8ZIOErrorZ {
6879 LDKCResult_CVec_u8ZIOErrorZ self;
6881 CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
6882 CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
6883 CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
6884 operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
6885 ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
6886 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; }
6887 LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
6888 LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
6889 const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
6890 const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
6892 class COption_CustomOnionMessageContentsZ {
6894 LDKCOption_CustomOnionMessageContentsZ self;
6896 COption_CustomOnionMessageContentsZ(const COption_CustomOnionMessageContentsZ&) = delete;
6897 COption_CustomOnionMessageContentsZ(COption_CustomOnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CustomOnionMessageContentsZ)); }
6898 COption_CustomOnionMessageContentsZ(LDKCOption_CustomOnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CustomOnionMessageContentsZ)); }
6899 operator LDKCOption_CustomOnionMessageContentsZ() && { LDKCOption_CustomOnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_CustomOnionMessageContentsZ)); return res; }
6900 ~COption_CustomOnionMessageContentsZ() { COption_CustomOnionMessageContentsZ_free(self); }
6901 COption_CustomOnionMessageContentsZ& operator=(COption_CustomOnionMessageContentsZ&& o) { COption_CustomOnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_CustomOnionMessageContentsZ)); return *this; }
6902 LDKCOption_CustomOnionMessageContentsZ* operator &() { return &self; }
6903 LDKCOption_CustomOnionMessageContentsZ* operator ->() { return &self; }
6904 const LDKCOption_CustomOnionMessageContentsZ* operator &() const { return &self; }
6905 const LDKCOption_CustomOnionMessageContentsZ* operator ->() const { return &self; }
6907 class CVec_ThirtyTwoBytesZ {
6909 LDKCVec_ThirtyTwoBytesZ self;
6911 CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
6912 CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
6913 CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
6914 operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
6915 ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
6916 CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
6917 LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
6918 LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
6919 const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
6920 const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
6922 class CResult_ChannelMonitorUpdateStatusNoneZ {
6924 LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
6926 CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
6927 CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
6928 CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
6929 operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
6930 ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
6931 CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
6932 LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
6933 LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
6934 const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
6935 const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
6937 class CResult_ClosingSignedDecodeErrorZ {
6939 LDKCResult_ClosingSignedDecodeErrorZ self;
6941 CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
6942 CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
6943 CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
6944 operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
6945 ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
6946 CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
6947 LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
6948 LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
6949 const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
6950 const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
6952 class CResult_NonePaymentErrorZ {
6954 LDKCResult_NonePaymentErrorZ self;
6956 CResult_NonePaymentErrorZ(const CResult_NonePaymentErrorZ&) = delete;
6957 CResult_NonePaymentErrorZ(CResult_NonePaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); }
6958 CResult_NonePaymentErrorZ(LDKCResult_NonePaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); }
6959 operator LDKCResult_NonePaymentErrorZ() && { LDKCResult_NonePaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentErrorZ)); return res; }
6960 ~CResult_NonePaymentErrorZ() { CResult_NonePaymentErrorZ_free(self); }
6961 CResult_NonePaymentErrorZ& operator=(CResult_NonePaymentErrorZ&& o) { CResult_NonePaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentErrorZ)); return *this; }
6962 LDKCResult_NonePaymentErrorZ* operator &() { return &self; }
6963 LDKCResult_NonePaymentErrorZ* operator ->() { return &self; }
6964 const LDKCResult_NonePaymentErrorZ* operator &() const { return &self; }
6965 const LDKCResult_NonePaymentErrorZ* operator ->() const { return &self; }
6967 class CVec_CResult_NoneAPIErrorZZ {
6969 LDKCVec_CResult_NoneAPIErrorZZ self;
6971 CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
6972 CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
6973 CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
6974 operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
6975 ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
6976 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; }
6977 LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
6978 LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
6979 const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
6980 const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
6982 class CResult_SchnorrSignatureNoneZ {
6984 LDKCResult_SchnorrSignatureNoneZ self;
6986 CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
6987 CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
6988 CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
6989 operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
6990 ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
6991 CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
6992 LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
6993 LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
6994 const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
6995 const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
6997 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
6999 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
7001 CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
7002 CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7003 CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7004 operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
7005 ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
7006 CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
7007 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
7008 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
7009 const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
7010 const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
7012 class CResult_ReceiveTlvsDecodeErrorZ {
7014 LDKCResult_ReceiveTlvsDecodeErrorZ self;
7016 CResult_ReceiveTlvsDecodeErrorZ(const CResult_ReceiveTlvsDecodeErrorZ&) = delete;
7017 CResult_ReceiveTlvsDecodeErrorZ(CResult_ReceiveTlvsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); }
7018 CResult_ReceiveTlvsDecodeErrorZ(LDKCResult_ReceiveTlvsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); }
7019 operator LDKCResult_ReceiveTlvsDecodeErrorZ() && { LDKCResult_ReceiveTlvsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ)); return res; }
7020 ~CResult_ReceiveTlvsDecodeErrorZ() { CResult_ReceiveTlvsDecodeErrorZ_free(self); }
7021 CResult_ReceiveTlvsDecodeErrorZ& operator=(CResult_ReceiveTlvsDecodeErrorZ&& o) { CResult_ReceiveTlvsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReceiveTlvsDecodeErrorZ)); return *this; }
7022 LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() { return &self; }
7023 LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() { return &self; }
7024 const LDKCResult_ReceiveTlvsDecodeErrorZ* operator &() const { return &self; }
7025 const LDKCResult_ReceiveTlvsDecodeErrorZ* operator ->() const { return &self; }
7027 class CResult_HTLCDescriptorDecodeErrorZ {
7029 LDKCResult_HTLCDescriptorDecodeErrorZ self;
7031 CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
7032 CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
7033 CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
7034 operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
7035 ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
7036 CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
7037 LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
7038 LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
7039 const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
7040 const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
7042 class CVec_RecentPaymentDetailsZ {
7044 LDKCVec_RecentPaymentDetailsZ self;
7046 CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
7047 CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
7048 CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
7049 operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
7050 ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
7051 CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
7052 LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
7053 LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
7054 const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
7055 const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
7057 class CVec_RouteHintHopZ {
7059 LDKCVec_RouteHintHopZ self;
7061 CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
7062 CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
7063 CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
7064 operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
7065 ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
7066 CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
7067 LDKCVec_RouteHintHopZ* operator &() { return &self; }
7068 LDKCVec_RouteHintHopZ* operator ->() { return &self; }
7069 const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
7070 const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
7072 class CResult_UntrustedStringDecodeErrorZ {
7074 LDKCResult_UntrustedStringDecodeErrorZ self;
7076 CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
7077 CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
7078 CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
7079 operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
7080 ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
7081 CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
7082 LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
7083 LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
7084 const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
7085 const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
7091 CVec_U5Z(const CVec_U5Z&) = delete;
7092 CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
7093 CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
7094 operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
7095 ~CVec_U5Z() { CVec_U5Z_free(self); }
7096 CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
7097 LDKCVec_U5Z* operator &() { return &self; }
7098 LDKCVec_U5Z* operator ->() { return &self; }
7099 const LDKCVec_U5Z* operator &() const { return &self; }
7100 const LDKCVec_U5Z* operator ->() const { return &self; }
7102 class CResult_PaymentParametersDecodeErrorZ {
7104 LDKCResult_PaymentParametersDecodeErrorZ self;
7106 CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
7107 CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
7108 CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
7109 operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
7110 ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
7111 CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
7112 LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
7113 LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
7114 const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
7115 const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
7117 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
7119 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
7121 C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
7122 C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7123 C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7124 operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
7125 ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
7126 C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
7127 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
7128 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
7129 const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
7130 const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
7132 class COption_U128Z {
7134 LDKCOption_U128Z self;
7136 COption_U128Z(const COption_U128Z&) = delete;
7137 COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
7138 COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
7139 operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
7140 ~COption_U128Z() { COption_U128Z_free(self); }
7141 COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
7142 LDKCOption_U128Z* operator &() { return &self; }
7143 LDKCOption_U128Z* operator ->() { return &self; }
7144 const LDKCOption_U128Z* operator &() const { return &self; }
7145 const LDKCOption_U128Z* operator ->() const { return &self; }
7147 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
7149 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
7151 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
7152 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7153 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7154 operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
7155 ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
7156 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
7157 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
7158 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
7159 const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
7160 const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
7162 class CResult_TxAckRbfDecodeErrorZ {
7164 LDKCResult_TxAckRbfDecodeErrorZ self;
7166 CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
7167 CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
7168 CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
7169 operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
7170 ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
7171 CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
7172 LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
7173 LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
7174 const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
7175 const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
7177 class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
7179 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
7181 CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
7182 CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7183 CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7184 operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
7185 ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
7186 CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
7187 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
7188 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
7189 const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
7190 const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
7192 class COption_UtxoLookupZ {
7194 LDKCOption_UtxoLookupZ self;
7196 COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
7197 COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
7198 COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
7199 operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
7200 ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
7201 COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
7202 LDKCOption_UtxoLookupZ* operator &() { return &self; }
7203 LDKCOption_UtxoLookupZ* operator ->() { return &self; }
7204 const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
7205 const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
7207 class CResult_PongDecodeErrorZ {
7209 LDKCResult_PongDecodeErrorZ self;
7211 CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
7212 CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
7213 CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
7214 operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
7215 ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
7216 CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
7217 LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
7218 LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
7219 const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
7220 const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
7222 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
7224 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
7226 CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
7227 CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7228 CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7229 operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
7230 ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
7231 CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
7232 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
7233 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
7234 const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
7235 const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
7237 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
7239 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
7241 C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
7242 C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7243 C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7244 operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
7245 ~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
7246 C2Tuple_OutPointCVec_MonitorUpdateIdZZ& operator=(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return *this; }
7247 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
7248 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
7249 const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
7250 const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
7252 class CResult_CVec_u8ZNoneZ {
7254 LDKCResult_CVec_u8ZNoneZ self;
7256 CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
7257 CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
7258 CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
7259 operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
7260 ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
7261 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; }
7262 LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
7263 LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
7264 const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
7265 const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
7267 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
7269 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
7271 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
7272 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7273 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7274 operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
7275 ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
7276 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; }
7277 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
7278 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
7279 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
7280 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
7282 class CResult_ChannelTransactionParametersDecodeErrorZ {
7284 LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
7286 CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
7287 CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
7288 CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
7289 operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
7290 ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
7291 CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
7292 LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
7293 LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
7294 const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
7295 const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
7297 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
7299 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
7301 CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
7302 CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7303 CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7304 operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
7305 ~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
7306 CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
7307 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
7308 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
7309 const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
7310 const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
7312 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
7314 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
7316 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
7317 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7318 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7319 operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
7320 ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
7321 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
7322 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7323 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7324 const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7325 const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7327 class CResult_InFlightHtlcsDecodeErrorZ {
7329 LDKCResult_InFlightHtlcsDecodeErrorZ self;
7331 CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
7332 CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
7333 CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
7334 operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
7335 ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
7336 CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
7337 LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
7338 LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
7339 const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
7340 const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
7342 class CResult_COption_HTLCDestinationZDecodeErrorZ {
7344 LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
7346 CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
7347 CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
7348 CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
7349 operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
7350 ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
7351 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; }
7352 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
7353 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
7354 const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
7355 const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
7357 class CResult_ThirtyTwoBytesNoneZ {
7359 LDKCResult_ThirtyTwoBytesNoneZ self;
7361 CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
7362 CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
7363 CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
7364 operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
7365 ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
7366 CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
7367 LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
7368 LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
7369 const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
7370 const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
7372 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
7374 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
7376 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
7377 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7378 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7379 operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
7380 ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
7381 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; }
7382 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
7383 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
7384 const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
7385 const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
7387 class CResult_BlindedHopDecodeErrorZ {
7389 LDKCResult_BlindedHopDecodeErrorZ self;
7391 CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
7392 CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
7393 CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
7394 operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
7395 ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
7396 CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
7397 LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
7398 LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
7399 const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
7400 const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
7402 class C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ {
7404 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ self;
7406 C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(const C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&) = delete;
7407 C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
7408 C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); }
7409 operator LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() && { LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return res; }
7410 ~C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ() { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); }
7411 C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ& operator=(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ&& o) { C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ)); return *this; }
7412 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() { return &self; }
7413 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() { return &self; }
7414 const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator &() const { return &self; }
7415 const LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
7417 class CResult_FixedPenaltyScorerDecodeErrorZ {
7419 LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
7421 CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
7422 CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
7423 CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
7424 operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
7425 ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
7426 CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
7427 LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
7428 LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
7429 const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
7430 const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
7432 class CVec_BlindedPathZ {
7434 LDKCVec_BlindedPathZ self;
7436 CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
7437 CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
7438 CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
7439 operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
7440 ~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
7441 CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
7442 LDKCVec_BlindedPathZ* operator &() { return &self; }
7443 LDKCVec_BlindedPathZ* operator ->() { return &self; }
7444 const LDKCVec_BlindedPathZ* operator &() const { return &self; }
7445 const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
7447 class CResult_NoneLightningErrorZ {
7449 LDKCResult_NoneLightningErrorZ self;
7451 CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
7452 CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
7453 CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
7454 operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
7455 ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
7456 CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
7457 LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
7458 LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
7459 const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
7460 const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
7462 class CResult_NonePeerHandleErrorZ {
7464 LDKCResult_NonePeerHandleErrorZ self;
7466 CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
7467 CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
7468 CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
7469 operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
7470 ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
7471 CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
7472 LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
7473 LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
7474 const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
7475 const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
7477 class CResult_TrustedCommitmentTransactionNoneZ {
7479 LDKCResult_TrustedCommitmentTransactionNoneZ self;
7481 CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
7482 CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
7483 CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
7484 operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
7485 ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
7486 CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
7487 LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
7488 LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
7489 const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
7490 const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
7492 class CResult_COption_EventZDecodeErrorZ {
7494 LDKCResult_COption_EventZDecodeErrorZ self;
7496 CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
7497 CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
7498 CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
7499 operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
7500 ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
7501 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; }
7502 LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
7503 LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
7504 const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
7505 const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
7507 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ {
7509 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ self;
7511 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&) = delete;
7512 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
7513 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); }
7514 operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return res; }
7515 ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); }
7516 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ& operator=(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ&& o) { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ)); return *this; }
7517 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() { return &self; }
7518 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() { return &self; }
7519 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator &() const { return &self; }
7520 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* operator ->() const { return &self; }
7522 class CResult_PaymentFailureReasonDecodeErrorZ {
7524 LDKCResult_PaymentFailureReasonDecodeErrorZ self;
7526 CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
7527 CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
7528 CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
7529 operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
7530 ~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
7531 CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
7532 LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
7533 LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
7534 const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
7535 const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
7537 class COption_SocketAddressZ {
7539 LDKCOption_SocketAddressZ self;
7541 COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
7542 COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
7543 COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
7544 operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
7545 ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
7546 COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
7547 LDKCOption_SocketAddressZ* operator &() { return &self; }
7548 LDKCOption_SocketAddressZ* operator ->() { return &self; }
7549 const LDKCOption_SocketAddressZ* operator &() const { return &self; }
7550 const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
7552 class CResult_COption_MonitorEventZDecodeErrorZ {
7554 LDKCResult_COption_MonitorEventZDecodeErrorZ self;
7556 CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
7557 CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
7558 CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
7559 operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
7560 ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
7561 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; }
7562 LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
7563 LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
7564 const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
7565 const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
7567 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
7569 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
7571 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
7572 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
7573 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
7574 operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
7575 ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
7576 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; }
7577 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
7578 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
7579 const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
7580 const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
7582 class CResult_DescriptionCreationErrorZ {
7584 LDKCResult_DescriptionCreationErrorZ self;
7586 CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
7587 CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
7588 CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
7589 operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
7590 ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
7591 CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
7592 LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
7593 LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
7594 const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
7595 const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
7597 class CResult_RoutingFeesDecodeErrorZ {
7599 LDKCResult_RoutingFeesDecodeErrorZ self;
7601 CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
7602 CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
7603 CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
7604 operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
7605 ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
7606 CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
7607 LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
7608 LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
7609 const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
7610 const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
7612 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
7614 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
7616 CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
7617 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)); }
7618 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)); }
7619 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; }
7620 ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
7621 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; }
7622 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
7623 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
7624 const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
7625 const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
7627 class CResult_PaymentRelayDecodeErrorZ {
7629 LDKCResult_PaymentRelayDecodeErrorZ self;
7631 CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
7632 CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
7633 CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
7634 operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
7635 ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
7636 CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
7637 LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
7638 LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
7639 const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
7640 const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
7642 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
7644 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
7646 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
7647 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
7648 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
7649 operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
7650 ~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
7651 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ& operator=(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return *this; }
7652 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
7653 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
7654 const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
7655 const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
7657 class CResult_QueryShortChannelIdsDecodeErrorZ {
7659 LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
7661 CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
7662 CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
7663 CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
7664 operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
7665 ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
7666 CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
7667 LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
7668 LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
7669 const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
7670 const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
7672 class CResult_VerifiedInvoiceRequestNoneZ {
7674 LDKCResult_VerifiedInvoiceRequestNoneZ self;
7676 CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
7677 CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
7678 CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
7679 operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
7680 ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
7681 CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
7682 LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
7683 LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
7684 const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
7685 const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
7687 class CResult_UpdateAddHTLCDecodeErrorZ {
7689 LDKCResult_UpdateAddHTLCDecodeErrorZ self;
7691 CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
7692 CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
7693 CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
7694 operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
7695 ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
7696 CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
7697 LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
7698 LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
7699 const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
7700 const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
7702 class COption_MonitorEventZ {
7704 LDKCOption_MonitorEventZ self;
7706 COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
7707 COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
7708 COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
7709 operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
7710 ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
7711 COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
7712 LDKCOption_MonitorEventZ* operator &() { return &self; }
7713 LDKCOption_MonitorEventZ* operator ->() { return &self; }
7714 const LDKCOption_MonitorEventZ* operator &() const { return &self; }
7715 const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
7717 class COption_TypeZ {
7719 LDKCOption_TypeZ self;
7721 COption_TypeZ(const COption_TypeZ&) = delete;
7722 COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
7723 COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
7724 operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
7725 ~COption_TypeZ() { COption_TypeZ_free(self); }
7726 COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
7727 LDKCOption_TypeZ* operator &() { return &self; }
7728 LDKCOption_TypeZ* operator ->() { return &self; }
7729 const LDKCOption_TypeZ* operator &() const { return &self; }
7730 const LDKCOption_TypeZ* operator ->() const { return &self; }
7732 class CResult_COption_TypeZDecodeErrorZ {
7734 LDKCResult_COption_TypeZDecodeErrorZ self;
7736 CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
7737 CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
7738 CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
7739 operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
7740 ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
7741 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; }
7742 LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
7743 LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
7744 const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
7745 const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
7747 class CResult_COption_PathFailureZDecodeErrorZ {
7749 LDKCResult_COption_PathFailureZDecodeErrorZ self;
7751 CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
7752 CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
7753 CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
7754 operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
7755 ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
7756 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; }
7757 LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
7758 LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
7759 const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
7760 const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
7762 class CResult_Bolt11InvoiceSignOrCreationErrorZ {
7764 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
7766 CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
7767 CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
7768 CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
7769 operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
7770 ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
7771 CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
7772 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
7773 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
7774 const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
7775 const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
7777 class CResult_UpdateFailHTLCDecodeErrorZ {
7779 LDKCResult_UpdateFailHTLCDecodeErrorZ self;
7781 CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
7782 CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
7783 CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
7784 operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
7785 ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
7786 CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
7787 LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
7788 LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
7789 const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
7790 const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
7792 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
7794 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
7796 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
7797 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
7798 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
7799 operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
7800 ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
7801 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; }
7802 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
7803 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
7804 const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
7805 const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
7807 class CResult_RevokeAndACKDecodeErrorZ {
7809 LDKCResult_RevokeAndACKDecodeErrorZ self;
7811 CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
7812 CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
7813 CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
7814 operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
7815 ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
7816 CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
7817 LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
7818 LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
7819 const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
7820 const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
7822 class CResult_SpendableOutputDescriptorDecodeErrorZ {
7824 LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
7826 CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
7827 CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
7828 CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
7829 operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
7830 ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
7831 CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
7832 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7833 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7834 const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7835 const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7837 class C2Tuple_PublicKeyCOption_SocketAddressZZ {
7839 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ self;
7841 C2Tuple_PublicKeyCOption_SocketAddressZZ(const C2Tuple_PublicKeyCOption_SocketAddressZZ&) = delete;
7842 C2Tuple_PublicKeyCOption_SocketAddressZZ(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); }
7843 C2Tuple_PublicKeyCOption_SocketAddressZZ(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); }
7844 operator LDKC2Tuple_PublicKeyCOption_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCOption_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); return res; }
7845 ~C2Tuple_PublicKeyCOption_SocketAddressZZ() { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); }
7846 C2Tuple_PublicKeyCOption_SocketAddressZZ& operator=(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); return *this; }
7847 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() { return &self; }
7848 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() { return &self; }
7849 const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() const { return &self; }
7850 const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() const { return &self; }
7852 class CResult_UnsignedChannelUpdateDecodeErrorZ {
7854 LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
7856 CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
7857 CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
7858 CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
7859 operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
7860 ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
7861 CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
7862 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
7863 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
7864 const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
7865 const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
7867 class CResult_PayeePubKeySecp256k1ErrorZ {
7869 LDKCResult_PayeePubKeySecp256k1ErrorZ self;
7871 CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
7872 CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
7873 CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
7874 operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
7875 ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
7876 CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
7877 LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
7878 LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
7879 const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
7880 const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
7882 class COption_BigEndianScalarZ {
7884 LDKCOption_BigEndianScalarZ self;
7886 COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
7887 COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
7888 COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
7889 operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
7890 ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
7891 COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
7892 LDKCOption_BigEndianScalarZ* operator &() { return &self; }
7893 LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
7894 const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
7895 const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
7897 class CResult_PublicKeySecp256k1ErrorZ {
7899 LDKCResult_PublicKeySecp256k1ErrorZ self;
7901 CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
7902 CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
7903 CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
7904 operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
7905 ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
7906 CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
7907 LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
7908 LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
7909 const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
7910 const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
7912 class CResult_CVec_ECDSASignatureZNoneZ {
7914 LDKCResult_CVec_ECDSASignatureZNoneZ self;
7916 CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
7917 CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
7918 CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
7919 operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
7920 ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
7921 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; }
7922 LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
7923 LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
7924 const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
7925 const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
7927 class CVec_BlindedHopZ {
7929 LDKCVec_BlindedHopZ self;
7931 CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
7932 CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
7933 CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
7934 operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
7935 ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
7936 CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
7937 LDKCVec_BlindedHopZ* operator &() { return &self; }
7938 LDKCVec_BlindedHopZ* operator ->() { return &self; }
7939 const LDKCVec_BlindedHopZ* operator &() const { return &self; }
7940 const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
7942 class CResult_COption_ClosureReasonZDecodeErrorZ {
7944 LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
7946 CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
7947 CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
7948 CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
7949 operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
7950 ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
7951 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; }
7952 LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
7953 LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
7954 const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
7955 const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
7957 class CResult_InvoiceErrorDecodeErrorZ {
7959 LDKCResult_InvoiceErrorDecodeErrorZ self;
7961 CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
7962 CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
7963 CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
7964 operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
7965 ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
7966 CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
7967 LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
7968 LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
7969 const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
7970 const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
7972 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
7974 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
7976 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
7977 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
7978 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
7979 operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
7980 ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
7981 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
7982 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
7983 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
7984 const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
7985 const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
7987 class CResult_RouteParametersDecodeErrorZ {
7989 LDKCResult_RouteParametersDecodeErrorZ self;
7991 CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
7992 CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
7993 CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
7994 operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
7995 ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
7996 CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
7997 LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
7998 LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
7999 const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
8000 const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
8002 class CResult_PrivateRouteCreationErrorZ {
8004 LDKCResult_PrivateRouteCreationErrorZ self;
8006 CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
8007 CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
8008 CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
8009 operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
8010 ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
8011 CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
8012 LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
8013 LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
8014 const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
8015 const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
8017 class CResult_NodeAliasDecodeErrorZ {
8019 LDKCResult_NodeAliasDecodeErrorZ self;
8021 CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
8022 CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
8023 CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
8024 operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
8025 ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
8026 CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
8027 LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
8028 LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
8029 const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
8030 const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
8032 class CVec_UpdateFulfillHTLCZ {
8034 LDKCVec_UpdateFulfillHTLCZ self;
8036 CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
8037 CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
8038 CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
8039 operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
8040 ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
8041 CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
8042 LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
8043 LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
8044 const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
8045 const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
8047 class CVec_C2Tuple_u32CVec_u8ZZZ {
8049 LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
8051 CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
8052 CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
8053 CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
8054 operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
8055 ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
8056 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; }
8057 LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
8058 LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
8059 const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
8060 const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
8062 class CResult_AnnouncementSignaturesDecodeErrorZ {
8064 LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
8066 CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
8067 CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
8068 CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
8069 operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
8070 ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
8071 CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
8072 LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
8073 LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
8074 const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
8075 const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
8077 class CResult_UpdateFulfillHTLCDecodeErrorZ {
8079 LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
8081 CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
8082 CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
8083 CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
8084 operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
8085 ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
8086 CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
8087 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
8088 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
8089 const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
8090 const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
8092 class CResult_TxCompleteDecodeErrorZ {
8094 LDKCResult_TxCompleteDecodeErrorZ self;
8096 CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
8097 CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
8098 CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
8099 operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
8100 ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
8101 CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
8102 LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
8103 LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
8104 const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
8105 const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
8107 class CResult_StrSecp256k1ErrorZ {
8109 LDKCResult_StrSecp256k1ErrorZ self;
8111 CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
8112 CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
8113 CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
8114 operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
8115 ~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
8116 CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
8117 LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
8118 LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
8119 const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
8120 const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
8122 class CResult_NodeFeaturesDecodeErrorZ {
8124 LDKCResult_NodeFeaturesDecodeErrorZ self;
8126 CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
8127 CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
8128 CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
8129 operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
8130 ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
8131 CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
8132 LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
8133 LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
8134 const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
8135 const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
8137 class CResult_InMemorySignerDecodeErrorZ {
8139 LDKCResult_InMemorySignerDecodeErrorZ self;
8141 CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
8142 CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
8143 CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
8144 operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
8145 ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
8146 CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
8147 LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
8148 LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
8149 const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
8150 const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
8152 class CResult_TxSignaturesDecodeErrorZ {
8154 LDKCResult_TxSignaturesDecodeErrorZ self;
8156 CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
8157 CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
8158 CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
8159 operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
8160 ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
8161 CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
8162 LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
8163 LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
8164 const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
8165 const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
8167 class CVec_HTLCDescriptorZ {
8169 LDKCVec_HTLCDescriptorZ self;
8171 CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
8172 CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
8173 CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
8174 operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
8175 ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
8176 CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
8177 LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
8178 LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
8179 const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
8180 const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
8182 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
8184 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
8186 CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
8187 CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8188 CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8189 operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
8190 ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
8191 CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
8192 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
8193 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
8194 const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
8195 const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
8197 class COption_PathFailureZ {
8199 LDKCOption_PathFailureZ self;
8201 COption_PathFailureZ(const COption_PathFailureZ&) = delete;
8202 COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
8203 COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
8204 operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
8205 ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
8206 COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
8207 LDKCOption_PathFailureZ* operator &() { return &self; }
8208 LDKCOption_PathFailureZ* operator ->() { return &self; }
8209 const LDKCOption_PathFailureZ* operator &() const { return &self; }
8210 const LDKCOption_PathFailureZ* operator ->() const { return &self; }
8212 class CVec_ECDSASignatureZ {
8214 LDKCVec_ECDSASignatureZ self;
8216 CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
8217 CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
8218 CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
8219 operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
8220 ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
8221 CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
8222 LDKCVec_ECDSASignatureZ* operator &() { return &self; }
8223 LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
8224 const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
8225 const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
8227 class CResult_ChannelUpdateInfoDecodeErrorZ {
8229 LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
8231 CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
8232 CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
8233 CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
8234 operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
8235 ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
8236 CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
8237 LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
8238 LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
8239 const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
8240 const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
8242 class CVec_UpdateFailHTLCZ {
8244 LDKCVec_UpdateFailHTLCZ self;
8246 CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
8247 CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
8248 CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
8249 operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
8250 ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
8251 CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
8252 LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
8253 LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
8254 const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
8255 const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
8259 LDKCVec_TxOutZ self;
8261 CVec_TxOutZ(const CVec_TxOutZ&) = delete;
8262 CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
8263 CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
8264 operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
8265 ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
8266 CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
8267 LDKCVec_TxOutZ* operator &() { return &self; }
8268 LDKCVec_TxOutZ* operator ->() { return &self; }
8269 const LDKCVec_TxOutZ* operator &() const { return &self; }
8270 const LDKCVec_TxOutZ* operator ->() const { return &self; }
8272 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
8274 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
8276 CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
8277 CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8278 CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8279 operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
8280 ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
8281 CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
8282 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
8283 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
8284 const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
8285 const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
8287 class CVec_SpendableOutputDescriptorZ {
8289 LDKCVec_SpendableOutputDescriptorZ self;
8291 CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
8292 CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
8293 CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
8294 operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
8295 ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
8296 CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
8297 LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
8298 LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
8299 const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
8300 const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
8302 class C2Tuple_OutPointCVec_u8ZZ {
8304 LDKC2Tuple_OutPointCVec_u8ZZ self;
8306 C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
8307 C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
8308 C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
8309 operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
8310 ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
8311 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; }
8312 LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
8313 LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
8314 const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
8315 const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
8317 class COption_C2Tuple_u64u64ZZ {
8319 LDKCOption_C2Tuple_u64u64ZZ self;
8321 COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
8322 COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
8323 COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
8324 operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
8325 ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
8326 COption_C2Tuple_u64u64ZZ& operator=(COption_C2Tuple_u64u64ZZ&& o) { COption_C2Tuple_u64u64ZZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); return *this; }
8327 LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
8328 LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
8329 const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
8330 const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
8332 class CResult_ChannelAnnouncementDecodeErrorZ {
8334 LDKCResult_ChannelAnnouncementDecodeErrorZ self;
8336 CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
8337 CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
8338 CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
8339 operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
8340 ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
8341 CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
8342 LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
8343 LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
8344 const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
8345 const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8347 class CResult_HTLCUpdateDecodeErrorZ {
8349 LDKCResult_HTLCUpdateDecodeErrorZ self;
8351 CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
8352 CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
8353 CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
8354 operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
8355 ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
8356 CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
8357 LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
8358 LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
8359 const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
8360 const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
8362 class CResult_TxAddInputDecodeErrorZ {
8364 LDKCResult_TxAddInputDecodeErrorZ self;
8366 CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
8367 CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
8368 CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
8369 operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
8370 ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
8371 CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
8372 LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
8373 LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
8374 const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
8375 const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
8377 class CVec_OutPointZ {
8379 LDKCVec_OutPointZ self;
8381 CVec_OutPointZ(const CVec_OutPointZ&) = delete;
8382 CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
8383 CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
8384 operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
8385 ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
8386 CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
8387 LDKCVec_OutPointZ* operator &() { return &self; }
8388 LDKCVec_OutPointZ* operator ->() { return &self; }
8389 const LDKCVec_OutPointZ* operator &() const { return &self; }
8390 const LDKCVec_OutPointZ* operator ->() const { return &self; }
8392 class CResult_TxInitRbfDecodeErrorZ {
8394 LDKCResult_TxInitRbfDecodeErrorZ self;
8396 CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
8397 CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
8398 CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
8399 operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
8400 ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
8401 CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
8402 LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
8403 LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
8404 const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
8405 const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
8407 class COption_WriteableScoreZ {
8409 LDKCOption_WriteableScoreZ self;
8411 COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
8412 COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
8413 COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
8414 operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
8415 ~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
8416 COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
8417 LDKCOption_WriteableScoreZ* operator &() { return &self; }
8418 LDKCOption_WriteableScoreZ* operator ->() { return &self; }
8419 const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
8420 const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
8426 CVec_StrZ(const CVec_StrZ&) = delete;
8427 CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
8428 CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
8429 operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
8430 ~CVec_StrZ() { CVec_StrZ_free(self); }
8431 CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
8432 LDKCVec_StrZ* operator &() { return &self; }
8433 LDKCVec_StrZ* operator ->() { return &self; }
8434 const LDKCVec_StrZ* operator &() const { return &self; }
8435 const LDKCVec_StrZ* operator ->() const { return &self; }
8437 class CResult_PositiveTimestampCreationErrorZ {
8439 LDKCResult_PositiveTimestampCreationErrorZ self;
8441 CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
8442 CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
8443 CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
8444 operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
8445 ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
8446 CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
8447 LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
8448 LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
8449 const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
8450 const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
8452 class CResult_ChannelMonitorUpdateDecodeErrorZ {
8454 LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
8456 CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
8457 CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
8458 CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
8459 operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
8460 ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
8461 CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
8462 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
8463 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
8464 const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
8465 const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
8467 class C2Tuple_BlindedPayInfoBlindedPathZ {
8469 LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
8471 C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
8472 C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
8473 C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
8474 operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
8475 ~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
8476 C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
8477 LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
8478 LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
8479 const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
8480 const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
8482 class CResult_ReplyChannelRangeDecodeErrorZ {
8484 LDKCResult_ReplyChannelRangeDecodeErrorZ self;
8486 CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
8487 CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
8488 CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
8489 operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
8490 ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
8491 CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
8492 LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
8493 LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
8494 const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
8495 const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
8497 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
8499 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
8501 CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
8502 CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
8503 CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
8504 operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
8505 ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
8506 CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
8507 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
8508 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
8509 const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
8510 const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8512 class CResult_TrustedClosingTransactionNoneZ {
8514 LDKCResult_TrustedClosingTransactionNoneZ self;
8516 CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
8517 CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
8518 CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
8519 operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
8520 ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
8521 CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
8522 LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
8523 LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
8524 const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
8525 const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
8527 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
8529 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
8531 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
8532 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
8533 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
8534 operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
8535 ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
8536 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; }
8537 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
8538 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
8539 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
8540 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
8542 class C2Tuple_PublicKeyTypeZ {
8544 LDKC2Tuple_PublicKeyTypeZ self;
8546 C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
8547 C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
8548 C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
8549 operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
8550 ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
8551 C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
8552 LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
8553 LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
8554 const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
8555 const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
8557 class CResult_TxRemoveOutputDecodeErrorZ {
8559 LDKCResult_TxRemoveOutputDecodeErrorZ self;
8561 CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
8562 CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
8563 CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
8564 operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
8565 ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
8566 CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
8567 LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
8568 LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
8569 const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
8570 const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
8572 class CResult_ChannelReestablishDecodeErrorZ {
8574 LDKCResult_ChannelReestablishDecodeErrorZ self;
8576 CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
8577 CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
8578 CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
8579 operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
8580 ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
8581 CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
8582 LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
8583 LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
8584 const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
8585 const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
8587 class CResult_OnionMessageDecodeErrorZ {
8589 LDKCResult_OnionMessageDecodeErrorZ self;
8591 CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
8592 CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
8593 CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
8594 operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
8595 ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
8596 CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
8597 LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
8598 LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
8599 const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
8600 const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
8602 class CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ {
8604 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ self;
8606 CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(const CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&) = delete;
8607 CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
8608 CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); }
8609 operator LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return res; }
8610 ~CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ() { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); }
8611 CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ)); return *this; }
8612 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() { return &self; }
8613 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
8614 const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
8615 const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
8617 class CResult_C2Tuple_CVec_u8ZusizeZNoneZ {
8619 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ self;
8621 CResult_C2Tuple_CVec_u8ZusizeZNoneZ(const CResult_C2Tuple_CVec_u8ZusizeZNoneZ&) = delete;
8622 CResult_C2Tuple_CVec_u8ZusizeZNoneZ(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
8623 CResult_C2Tuple_CVec_u8ZusizeZNoneZ(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); }
8624 operator LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ() && { LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return res; }
8625 ~CResult_C2Tuple_CVec_u8ZusizeZNoneZ() { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); }
8626 CResult_C2Tuple_CVec_u8ZusizeZNoneZ& operator=(CResult_C2Tuple_CVec_u8ZusizeZNoneZ&& o) { CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8ZusizeZNoneZ)); return *this; }
8627 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() { return &self; }
8628 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() { return &self; }
8629 const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator &() const { return &self; }
8630 const LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* operator ->() const { return &self; }
8632 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
8634 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
8636 CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
8637 CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
8638 CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
8639 operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
8640 ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
8641 CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
8642 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
8643 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
8644 const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
8645 const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
8647 class CResult_InitFeaturesDecodeErrorZ {
8649 LDKCResult_InitFeaturesDecodeErrorZ self;
8651 CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
8652 CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
8653 CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
8654 operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
8655 ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
8656 CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
8657 LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
8658 LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
8659 const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
8660 const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
8662 class CResult_PublicKeyNoneZ {
8664 LDKCResult_PublicKeyNoneZ self;
8666 CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
8667 CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
8668 CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
8669 operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
8670 ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
8671 CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
8672 LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
8673 LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
8674 const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
8675 const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
8677 class CResult_PingDecodeErrorZ {
8679 LDKCResult_PingDecodeErrorZ self;
8681 CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
8682 CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
8683 CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
8684 operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
8685 ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
8686 CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
8687 LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
8688 LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
8689 const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
8690 const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
8692 class CResult_BlindedHopFeaturesDecodeErrorZ {
8694 LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
8696 CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
8697 CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
8698 CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
8699 operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
8700 ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
8701 CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
8702 LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
8703 LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
8704 const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
8705 const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
8707 class CVec_TransactionOutputsZ {
8709 LDKCVec_TransactionOutputsZ self;
8711 CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
8712 CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
8713 CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
8714 operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
8715 ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
8716 CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
8717 LDKCVec_TransactionOutputsZ* operator &() { return &self; }
8718 LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
8719 const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
8720 const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
8722 class COption_HTLCClaimZ {
8724 LDKCOption_HTLCClaimZ self;
8726 COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
8727 COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
8728 COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
8729 operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
8730 ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
8731 COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
8732 LDKCOption_HTLCClaimZ* operator &() { return &self; }
8733 LDKCOption_HTLCClaimZ* operator ->() { return &self; }
8734 const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
8735 const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
8737 class COption_boolZ {
8739 LDKCOption_boolZ self;
8741 COption_boolZ(const COption_boolZ&) = delete;
8742 COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
8743 COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
8744 operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
8745 ~COption_boolZ() { COption_boolZ_free(self); }
8746 COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
8747 LDKCOption_boolZ* operator &() { return &self; }
8748 LDKCOption_boolZ* operator ->() { return &self; }
8749 const LDKCOption_boolZ* operator &() const { return &self; }
8750 const LDKCOption_boolZ* operator ->() const { return &self; }
8752 class CVec_CVec_u8ZZ {
8754 LDKCVec_CVec_u8ZZ self;
8756 CVec_CVec_u8ZZ(const CVec_CVec_u8ZZ&) = delete;
8757 CVec_CVec_u8ZZ(CVec_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CVec_u8ZZ)); }
8758 CVec_CVec_u8ZZ(LDKCVec_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CVec_u8ZZ)); }
8759 operator LDKCVec_CVec_u8ZZ() && { LDKCVec_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCVec_CVec_u8ZZ)); return res; }
8760 ~CVec_CVec_u8ZZ() { CVec_CVec_u8ZZ_free(self); }
8761 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; }
8762 LDKCVec_CVec_u8ZZ* operator &() { return &self; }
8763 LDKCVec_CVec_u8ZZ* operator ->() { return &self; }
8764 const LDKCVec_CVec_u8ZZ* operator &() const { return &self; }
8765 const LDKCVec_CVec_u8ZZ* operator ->() const { return &self; }
8767 class CResult_ProbabilisticScorerDecodeErrorZ {
8769 LDKCResult_ProbabilisticScorerDecodeErrorZ self;
8771 CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
8772 CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
8773 CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
8774 operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
8775 ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
8776 CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
8777 LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
8778 LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
8779 const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
8780 const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
8782 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
8784 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
8786 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(const CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&) = delete;
8787 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
8788 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
8789 operator LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return res; }
8790 ~CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); }
8791 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ& operator=(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return *this; }
8792 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() { return &self; }
8793 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() { return &self; }
8794 const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() const { return &self; }
8795 const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() const { return &self; }
8797 class CResult_COption_CustomOnionMessageContentsZDecodeErrorZ {
8799 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ self;
8801 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(const CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&) = delete;
8802 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); }
8803 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); }
8804 operator LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); return res; }
8805 ~CResult_COption_CustomOnionMessageContentsZDecodeErrorZ() { CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(self); }
8806 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ& operator=(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ&& o) { CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_CustomOnionMessageContentsZDecodeErrorZ)); return *this; }
8807 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
8808 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
8809 const LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
8810 const LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
8812 class CResult_ShutdownScriptDecodeErrorZ {
8814 LDKCResult_ShutdownScriptDecodeErrorZ self;
8816 CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
8817 CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
8818 CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
8819 operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
8820 ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
8821 CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
8822 LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
8823 LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
8824 const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
8825 const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
8827 class C2Tuple_usizeTransactionZ {
8829 LDKC2Tuple_usizeTransactionZ self;
8831 C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
8832 C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
8833 C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
8834 operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
8835 ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
8836 C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
8837 LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
8838 LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
8839 const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
8840 const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
8842 class CResult_NodeAnnouncementDecodeErrorZ {
8844 LDKCResult_NodeAnnouncementDecodeErrorZ self;
8846 CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
8847 CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
8848 CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
8849 operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
8850 ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
8851 CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
8852 LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
8853 LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
8854 const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
8855 const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
8857 class CVec_FutureZ {
8859 LDKCVec_FutureZ self;
8861 CVec_FutureZ(const CVec_FutureZ&) = delete;
8862 CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
8863 CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
8864 operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
8865 ~CVec_FutureZ() { CVec_FutureZ_free(self); }
8866 CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
8867 LDKCVec_FutureZ* operator &() { return &self; }
8868 LDKCVec_FutureZ* operator ->() { return &self; }
8869 const LDKCVec_FutureZ* operator &() const { return &self; }
8870 const LDKCVec_FutureZ* operator ->() const { return &self; }
8872 class CVec_ChannelMonitorZ {
8874 LDKCVec_ChannelMonitorZ self;
8876 CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
8877 CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
8878 CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
8879 operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
8880 ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
8881 CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
8882 LDKCVec_ChannelMonitorZ* operator &() { return &self; }
8883 LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
8884 const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
8885 const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
8887 class CResult_AcceptChannelV2DecodeErrorZ {
8889 LDKCResult_AcceptChannelV2DecodeErrorZ self;
8891 CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
8892 CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
8893 CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
8894 operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
8895 ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
8896 CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
8897 LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
8898 LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
8899 const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
8900 const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
8902 class CResult_TxCreationKeysDecodeErrorZ {
8904 LDKCResult_TxCreationKeysDecodeErrorZ self;
8906 CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
8907 CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
8908 CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
8909 operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
8910 ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
8911 CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
8912 LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
8913 LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
8914 const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
8915 const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
8917 class CResult_RouteHopDecodeErrorZ {
8919 LDKCResult_RouteHopDecodeErrorZ self;
8921 CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
8922 CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
8923 CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
8924 operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
8925 ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
8926 CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
8927 LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
8928 LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
8929 const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
8930 const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
8932 class CVec_HTLCOutputInCommitmentZ {
8934 LDKCVec_HTLCOutputInCommitmentZ self;
8936 CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
8937 CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
8938 CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
8939 operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
8940 ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
8941 CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
8942 LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
8943 LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
8944 const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
8945 const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
8947 class CResult_CoinSelectionNoneZ {
8949 LDKCResult_CoinSelectionNoneZ self;
8951 CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
8952 CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
8953 CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
8954 operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
8955 ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
8956 CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
8957 LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
8958 LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
8959 const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
8960 const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
8962 class C2Tuple_ThirtyTwoBytesPublicKeyZ {
8964 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
8966 C2Tuple_ThirtyTwoBytesPublicKeyZ(const C2Tuple_ThirtyTwoBytesPublicKeyZ&) = delete;
8967 C2Tuple_ThirtyTwoBytesPublicKeyZ(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); }
8968 C2Tuple_ThirtyTwoBytesPublicKeyZ(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); }
8969 operator LDKC2Tuple_ThirtyTwoBytesPublicKeyZ() && { LDKC2Tuple_ThirtyTwoBytesPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); return res; }
8970 ~C2Tuple_ThirtyTwoBytesPublicKeyZ() { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); }
8971 C2Tuple_ThirtyTwoBytesPublicKeyZ& operator=(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); return *this; }
8972 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() { return &self; }
8973 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() { return &self; }
8974 const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() const { return &self; }
8975 const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() const { return &self; }
8977 class CResult_SiPrefixBolt11ParseErrorZ {
8979 LDKCResult_SiPrefixBolt11ParseErrorZ self;
8981 CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
8982 CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
8983 CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
8984 operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
8985 ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
8986 CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
8987 LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
8988 LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
8989 const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
8990 const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
8992 class CResult_BlindedPathDecodeErrorZ {
8994 LDKCResult_BlindedPathDecodeErrorZ self;
8996 CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
8997 CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
8998 CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
8999 operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
9000 ~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
9001 CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
9002 LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
9003 LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
9004 const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
9005 const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
9007 class CVec_BalanceZ {
9009 LDKCVec_BalanceZ self;
9011 CVec_BalanceZ(const CVec_BalanceZ&) = delete;
9012 CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
9013 CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
9014 operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
9015 ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
9016 CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
9017 LDKCVec_BalanceZ* operator &() { return &self; }
9018 LDKCVec_BalanceZ* operator ->() { return &self; }
9019 const LDKCVec_BalanceZ* operator &() const { return &self; }
9020 const LDKCVec_BalanceZ* operator ->() const { return &self; }
9022 class CResult_NoneIOErrorZ {
9024 LDKCResult_NoneIOErrorZ self;
9026 CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
9027 CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
9028 CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
9029 operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
9030 ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
9031 CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
9032 LDKCResult_NoneIOErrorZ* operator &() { return &self; }
9033 LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
9034 const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
9035 const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
9037 class CResult_MaxDustHTLCExposureDecodeErrorZ {
9039 LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
9041 CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
9042 CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
9043 CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
9044 operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
9045 ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
9046 CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
9047 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
9048 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
9049 const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
9050 const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
9052 class CVec_CommitmentTransactionZ {
9054 LDKCVec_CommitmentTransactionZ self;
9056 CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
9057 CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
9058 CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
9059 operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
9060 ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
9061 CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
9062 LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
9063 LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
9064 const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
9065 const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
9067 class CResult_FundingSignedDecodeErrorZ {
9069 LDKCResult_FundingSignedDecodeErrorZ self;
9071 CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
9072 CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
9073 CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
9074 operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
9075 ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
9076 CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
9077 LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
9078 LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
9079 const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
9080 const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
9082 class CResult_RecoverableSignatureNoneZ {
9084 LDKCResult_RecoverableSignatureNoneZ self;
9086 CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
9087 CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
9088 CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
9089 operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
9090 ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
9091 CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
9092 LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
9093 LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
9094 const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
9095 const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
9097 class CResult_SocketAddressDecodeErrorZ {
9099 LDKCResult_SocketAddressDecodeErrorZ self;
9101 CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
9102 CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
9103 CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
9104 operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
9105 ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
9106 CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
9107 LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
9108 LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
9109 const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
9110 const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
9116 C2Tuple_Z(const C2Tuple_Z&) = delete;
9117 C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
9118 C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
9119 operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
9120 ~C2Tuple_Z() { C2Tuple_Z_free(self); }
9121 C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
9122 LDKC2Tuple_Z* operator &() { return &self; }
9123 LDKC2Tuple_Z* operator ->() { return &self; }
9124 const LDKC2Tuple_Z* operator &() const { return &self; }
9125 const LDKC2Tuple_Z* operator ->() const { return &self; }
9127 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
9129 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
9131 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
9132 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9133 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9134 operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
9135 ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
9136 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; }
9137 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
9138 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
9139 const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
9140 const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
9146 CVec_PathZ(const CVec_PathZ&) = delete;
9147 CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
9148 CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
9149 operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
9150 ~CVec_PathZ() { CVec_PathZ_free(self); }
9151 CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
9152 LDKCVec_PathZ* operator &() { return &self; }
9153 LDKCVec_PathZ* operator ->() { return &self; }
9154 const LDKCVec_PathZ* operator &() const { return &self; }
9155 const LDKCVec_PathZ* operator ->() const { return &self; }
9157 class CResult_NetworkGraphDecodeErrorZ {
9159 LDKCResult_NetworkGraphDecodeErrorZ self;
9161 CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
9162 CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
9163 CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
9164 operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
9165 ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
9166 CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
9167 LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
9168 LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
9169 const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
9170 const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
9172 class CResult_NodeInfoDecodeErrorZ {
9174 LDKCResult_NodeInfoDecodeErrorZ self;
9176 CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
9177 CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
9178 CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
9179 operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
9180 ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
9181 CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
9182 LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
9183 LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
9184 const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
9185 const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
9187 class CVec_NodeIdZ {
9189 LDKCVec_NodeIdZ self;
9191 CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
9192 CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
9193 CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
9194 operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
9195 ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
9196 CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
9197 LDKCVec_NodeIdZ* operator &() { return &self; }
9198 LDKCVec_NodeIdZ* operator ->() { return &self; }
9199 const LDKCVec_NodeIdZ* operator &() const { return &self; }
9200 const LDKCVec_NodeIdZ* operator ->() const { return &self; }
9206 CVec_u8Z(const CVec_u8Z&) = delete;
9207 CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
9208 CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
9209 operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
9210 ~CVec_u8Z() { CVec_u8Z_free(self); }
9211 CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
9212 LDKCVec_u8Z* operator &() { return &self; }
9213 LDKCVec_u8Z* operator ->() { return &self; }
9214 const LDKCVec_u8Z* operator &() const { return &self; }
9215 const LDKCVec_u8Z* operator ->() const { return &self; }
9217 class CResult_RouteLightningErrorZ {
9219 LDKCResult_RouteLightningErrorZ self;
9221 CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
9222 CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
9223 CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
9224 operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
9225 ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
9226 CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
9227 LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
9228 LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
9229 const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
9230 const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
9232 class CResult_NonePaymentSendFailureZ {
9234 LDKCResult_NonePaymentSendFailureZ self;
9236 CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
9237 CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
9238 CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
9239 operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
9240 ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
9241 CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
9242 LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
9243 LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
9244 const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
9245 const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
9247 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
9249 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
9251 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
9252 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9253 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9254 operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
9255 ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
9256 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; }
9257 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
9258 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
9259 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
9260 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
9262 class CResult_ChannelPublicKeysDecodeErrorZ {
9264 LDKCResult_ChannelPublicKeysDecodeErrorZ self;
9266 CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
9267 CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
9268 CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
9269 operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
9270 ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
9271 CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
9272 LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
9273 LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
9274 const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
9275 const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
9277 class CVec_ClaimedHTLCZ {
9279 LDKCVec_ClaimedHTLCZ self;
9281 CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
9282 CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
9283 CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
9284 operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
9285 ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
9286 CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
9287 LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
9288 LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
9289 const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
9290 const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
9292 class COption_CVec_ThirtyTwoBytesZZ {
9294 LDKCOption_CVec_ThirtyTwoBytesZZ self;
9296 COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
9297 COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
9298 COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
9299 operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
9300 ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
9301 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; }
9302 LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
9303 LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
9304 const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
9305 const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
9307 class CVec_SocketAddressZ {
9309 LDKCVec_SocketAddressZ self;
9311 CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
9312 CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
9313 CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
9314 operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
9315 ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
9316 CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
9317 LDKCVec_SocketAddressZ* operator &() { return &self; }
9318 LDKCVec_SocketAddressZ* operator ->() { return &self; }
9319 const LDKCVec_SocketAddressZ* operator &() const { return &self; }
9320 const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
9322 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
9324 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
9326 CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
9327 CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
9328 CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
9329 operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
9330 ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
9331 CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
9332 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
9333 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
9334 const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
9335 const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
9337 class CResult_HolderCommitmentTransactionDecodeErrorZ {
9339 LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
9341 CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
9342 CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
9343 CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
9344 operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
9345 ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
9346 CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
9347 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
9348 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
9349 const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
9350 const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
9352 class CResult_WarningMessageDecodeErrorZ {
9354 LDKCResult_WarningMessageDecodeErrorZ self;
9356 CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
9357 CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
9358 CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
9359 operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
9360 ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
9361 CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
9362 LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
9363 LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
9364 const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
9365 const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
9367 class CResult_ChannelCounterpartyDecodeErrorZ {
9369 LDKCResult_ChannelCounterpartyDecodeErrorZ self;
9371 CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
9372 CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
9373 CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
9374 operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
9375 ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
9376 CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
9377 LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
9378 LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
9379 const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
9380 const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
9382 class CResult_InitDecodeErrorZ {
9384 LDKCResult_InitDecodeErrorZ self;
9386 CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
9387 CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
9388 CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
9389 operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
9390 ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
9391 CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
9392 LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
9393 LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
9394 const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
9395 const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
9397 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
9399 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
9401 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
9402 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
9403 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
9404 operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
9405 ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
9406 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; }
9407 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
9408 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
9409 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
9410 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
9412 class CResult_ClaimedHTLCDecodeErrorZ {
9414 LDKCResult_ClaimedHTLCDecodeErrorZ self;
9416 CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
9417 CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
9418 CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
9419 operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
9420 ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
9421 CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
9422 LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
9423 LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
9424 const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
9425 const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
9427 class CResult_PaymentPurposeDecodeErrorZ {
9429 LDKCResult_PaymentPurposeDecodeErrorZ self;
9431 CResult_PaymentPurposeDecodeErrorZ(const CResult_PaymentPurposeDecodeErrorZ&) = delete;
9432 CResult_PaymentPurposeDecodeErrorZ(CResult_PaymentPurposeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); }
9433 CResult_PaymentPurposeDecodeErrorZ(LDKCResult_PaymentPurposeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); }
9434 operator LDKCResult_PaymentPurposeDecodeErrorZ() && { LDKCResult_PaymentPurposeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); return res; }
9435 ~CResult_PaymentPurposeDecodeErrorZ() { CResult_PaymentPurposeDecodeErrorZ_free(self); }
9436 CResult_PaymentPurposeDecodeErrorZ& operator=(CResult_PaymentPurposeDecodeErrorZ&& o) { CResult_PaymentPurposeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); return *this; }
9437 LDKCResult_PaymentPurposeDecodeErrorZ* operator &() { return &self; }
9438 LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() { return &self; }
9439 const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
9440 const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
9442 class CVec_MonitorUpdateIdZ {
9444 LDKCVec_MonitorUpdateIdZ self;
9446 CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
9447 CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
9448 CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
9449 operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
9450 ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
9451 CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
9452 LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
9453 LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
9454 const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
9455 const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
9457 class CResult_OutPointDecodeErrorZ {
9459 LDKCResult_OutPointDecodeErrorZ self;
9461 CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
9462 CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
9463 CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
9464 operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
9465 ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
9466 CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
9467 LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
9468 LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
9469 const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
9470 const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
9472 class CVec_ChannelDetailsZ {
9474 LDKCVec_ChannelDetailsZ self;
9476 CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
9477 CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
9478 CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
9479 operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
9480 ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
9481 CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
9482 LDKCVec_ChannelDetailsZ* operator &() { return &self; }
9483 LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
9484 const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
9485 const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
9487 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
9489 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
9491 CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
9492 CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
9493 CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
9494 operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
9495 ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
9496 CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
9497 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
9498 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
9499 const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
9500 const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
9502 class CVec_MessageSendEventZ {
9504 LDKCVec_MessageSendEventZ self;
9506 CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
9507 CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
9508 CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
9509 operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
9510 ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
9511 CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
9512 LDKCVec_MessageSendEventZ* operator &() { return &self; }
9513 LDKCVec_MessageSendEventZ* operator ->() { return &self; }
9514 const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
9515 const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
9517 class CResult_RouteHintHopDecodeErrorZ {
9519 LDKCResult_RouteHintHopDecodeErrorZ self;
9521 CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
9522 CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
9523 CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
9524 operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
9525 ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
9526 CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
9527 LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
9528 LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
9529 const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
9530 const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
9532 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
9534 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
9536 CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
9537 CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
9538 CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
9539 operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
9540 ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
9541 CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
9542 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
9543 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
9544 const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
9545 const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
9547 class CResult_BlindedPayInfoDecodeErrorZ {
9549 LDKCResult_BlindedPayInfoDecodeErrorZ self;
9551 CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
9552 CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
9553 CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
9554 operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
9555 ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
9556 CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
9557 LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
9558 LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
9559 const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
9560 const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
9562 class CResult_ThirtyTwoBytesAPIErrorZ {
9564 LDKCResult_ThirtyTwoBytesAPIErrorZ self;
9566 CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
9567 CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
9568 CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
9569 operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
9570 ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
9571 CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
9572 LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
9573 LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
9574 const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
9575 const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
9577 class COption_ChannelShutdownStateZ {
9579 LDKCOption_ChannelShutdownStateZ self;
9581 COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
9582 COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
9583 COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
9584 operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
9585 ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
9586 COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
9587 LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
9588 LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
9589 const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
9590 const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
9592 class CResult_CVec_CVec_u8ZZNoneZ {
9594 LDKCResult_CVec_CVec_u8ZZNoneZ self;
9596 CResult_CVec_CVec_u8ZZNoneZ(const CResult_CVec_CVec_u8ZZNoneZ&) = delete;
9597 CResult_CVec_CVec_u8ZZNoneZ(CResult_CVec_CVec_u8ZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_CVec_u8ZZNoneZ)); }
9598 CResult_CVec_CVec_u8ZZNoneZ(LDKCResult_CVec_CVec_u8ZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); }
9599 operator LDKCResult_CVec_CVec_u8ZZNoneZ() && { LDKCResult_CVec_CVec_u8ZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ)); return res; }
9600 ~CResult_CVec_CVec_u8ZZNoneZ() { CResult_CVec_CVec_u8ZZNoneZ_free(self); }
9601 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; }
9602 LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() { return &self; }
9603 LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() { return &self; }
9604 const LDKCResult_CVec_CVec_u8ZZNoneZ* operator &() const { return &self; }
9605 const LDKCResult_CVec_CVec_u8ZZNoneZ* operator ->() const { return &self; }
9607 class CResult_AcceptChannelDecodeErrorZ {
9609 LDKCResult_AcceptChannelDecodeErrorZ self;
9611 CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
9612 CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
9613 CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
9614 operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
9615 ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
9616 CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
9617 LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
9618 LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
9619 const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
9620 const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
9622 class CResult_HostnameDecodeErrorZ {
9624 LDKCResult_HostnameDecodeErrorZ self;
9626 CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
9627 CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
9628 CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
9629 operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
9630 ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
9631 CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
9632 LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
9633 LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
9634 const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
9635 const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
9637 class C2Tuple_u64u16Z {
9639 LDKC2Tuple_u64u16Z self;
9641 C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
9642 C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
9643 C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
9644 operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
9645 ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
9646 C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
9647 LDKC2Tuple_u64u16Z* operator &() { return &self; }
9648 LDKC2Tuple_u64u16Z* operator ->() { return &self; }
9649 const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
9650 const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
9652 class COption_ThirtyTwoBytesZ {
9654 LDKCOption_ThirtyTwoBytesZ self;
9656 COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
9657 COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
9658 COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
9659 operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
9660 ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
9661 COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
9662 LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
9663 LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
9664 const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
9665 const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
9671 CVec_u64Z(const CVec_u64Z&) = delete;
9672 CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
9673 CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
9674 operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
9675 ~CVec_u64Z() { CVec_u64Z_free(self); }
9676 CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
9677 LDKCVec_u64Z* operator &() { return &self; }
9678 LDKCVec_u64Z* operator ->() { return &self; }
9679 const LDKCVec_u64Z* operator &() const { return &self; }
9680 const LDKCVec_u64Z* operator ->() const { return &self; }
9682 class COption_SecretKeyZ {
9684 LDKCOption_SecretKeyZ self;
9686 COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
9687 COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
9688 COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
9689 operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
9690 ~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
9691 COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
9692 LDKCOption_SecretKeyZ* operator &() { return &self; }
9693 LDKCOption_SecretKeyZ* operator ->() { return &self; }
9694 const LDKCOption_SecretKeyZ* operator &() const { return &self; }
9695 const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
9697 class CResult_ThirtyTwoBytesPaymentErrorZ {
9699 LDKCResult_ThirtyTwoBytesPaymentErrorZ self;
9701 CResult_ThirtyTwoBytesPaymentErrorZ(const CResult_ThirtyTwoBytesPaymentErrorZ&) = delete;
9702 CResult_ThirtyTwoBytesPaymentErrorZ(CResult_ThirtyTwoBytesPaymentErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); }
9703 CResult_ThirtyTwoBytesPaymentErrorZ(LDKCResult_ThirtyTwoBytesPaymentErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); }
9704 operator LDKCResult_ThirtyTwoBytesPaymentErrorZ() && { LDKCResult_ThirtyTwoBytesPaymentErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ)); return res; }
9705 ~CResult_ThirtyTwoBytesPaymentErrorZ() { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); }
9706 CResult_ThirtyTwoBytesPaymentErrorZ& operator=(CResult_ThirtyTwoBytesPaymentErrorZ&& o) { CResult_ThirtyTwoBytesPaymentErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentErrorZ)); return *this; }
9707 LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() { return &self; }
9708 LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() { return &self; }
9709 const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator &() const { return &self; }
9710 const LDKCResult_ThirtyTwoBytesPaymentErrorZ* operator ->() const { return &self; }
9712 class COption_EventZ {
9714 LDKCOption_EventZ self;
9716 COption_EventZ(const COption_EventZ&) = delete;
9717 COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
9718 COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
9719 operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
9720 ~COption_EventZ() { COption_EventZ_free(self); }
9721 COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
9722 LDKCOption_EventZ* operator &() { return &self; }
9723 LDKCOption_EventZ* operator ->() { return &self; }
9724 const LDKCOption_EventZ* operator &() const { return &self; }
9725 const LDKCOption_EventZ* operator ->() const { return &self; }
9727 class CResult_ChannelTypeFeaturesDecodeErrorZ {
9729 LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
9731 CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
9732 CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
9733 CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
9734 operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
9735 ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
9736 CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
9737 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
9738 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
9739 const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
9740 const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
9742 class COption_CVec_SocketAddressZZ {
9744 LDKCOption_CVec_SocketAddressZZ self;
9746 COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
9747 COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
9748 COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
9749 operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
9750 ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
9751 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; }
9752 LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
9753 LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
9754 const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
9755 const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
9757 class CVec_RouteHintZ {
9759 LDKCVec_RouteHintZ self;
9761 CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
9762 CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
9763 CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
9764 operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
9765 ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
9766 CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
9767 LDKCVec_RouteHintZ* operator &() { return &self; }
9768 LDKCVec_RouteHintZ* operator ->() { return &self; }
9769 const LDKCVec_RouteHintZ* operator &() const { return &self; }
9770 const LDKCVec_RouteHintZ* operator ->() const { return &self; }
9772 class COption_u16Z {
9774 LDKCOption_u16Z self;
9776 COption_u16Z(const COption_u16Z&) = delete;
9777 COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
9778 COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
9779 operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
9780 ~COption_u16Z() { COption_u16Z_free(self); }
9781 COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
9782 LDKCOption_u16Z* operator &() { return &self; }
9783 LDKCOption_u16Z* operator ->() { return &self; }
9784 const LDKCOption_u16Z* operator &() const { return &self; }
9785 const LDKCOption_u16Z* operator ->() const { return &self; }
9787 class COption_PaymentFailureReasonZ {
9789 LDKCOption_PaymentFailureReasonZ self;
9791 COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
9792 COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
9793 COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
9794 operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
9795 ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
9796 COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
9797 LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
9798 LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
9799 const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
9800 const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
9802 class CResult_ECDSASignatureNoneZ {
9804 LDKCResult_ECDSASignatureNoneZ self;
9806 CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
9807 CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
9808 CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
9809 operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
9810 ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
9811 CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
9812 LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
9813 LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
9814 const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
9815 const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
9817 class CVec_WitnessZ {
9819 LDKCVec_WitnessZ self;
9821 CVec_WitnessZ(const CVec_WitnessZ&) = delete;
9822 CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
9823 CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
9824 operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
9825 ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
9826 CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
9827 LDKCVec_WitnessZ* operator &() { return &self; }
9828 LDKCVec_WitnessZ* operator ->() { return &self; }
9829 const LDKCVec_WitnessZ* operator &() const { return &self; }
9830 const LDKCVec_WitnessZ* operator ->() const { return &self; }
9832 class CResult_BlindedTailDecodeErrorZ {
9834 LDKCResult_BlindedTailDecodeErrorZ self;
9836 CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
9837 CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
9838 CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
9839 operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
9840 ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
9841 CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
9842 LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
9843 LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
9844 const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
9845 const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
9847 class CResult_SocketAddressSocketAddressParseErrorZ {
9849 LDKCResult_SocketAddressSocketAddressParseErrorZ self;
9851 CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
9852 CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
9853 CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
9854 operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
9855 ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
9856 CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
9857 LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
9858 LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
9859 const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
9860 const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
9862 class COption_C2Tuple_u64u16ZZ {
9864 LDKCOption_C2Tuple_u64u16ZZ self;
9866 COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
9867 COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
9868 COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
9869 operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
9870 ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
9871 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; }
9872 LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
9873 LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
9874 const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
9875 const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
9877 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
9879 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
9881 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
9882 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
9883 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
9884 operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
9885 ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
9886 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
9887 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
9888 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
9889 const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
9890 const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
9892 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
9894 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
9896 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
9897 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
9898 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
9899 operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
9900 ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
9901 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; }
9902 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
9903 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
9904 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
9905 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
9907 class CResult_ChannelDerivationParametersDecodeErrorZ {
9909 LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
9911 CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
9912 CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
9913 CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
9914 operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
9915 ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
9916 CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
9917 LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
9918 LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
9919 const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
9920 const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
9922 class CResult_PaymentConstraintsDecodeErrorZ {
9924 LDKCResult_PaymentConstraintsDecodeErrorZ self;
9926 CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
9927 CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
9928 CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
9929 operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
9930 ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
9931 CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
9932 LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
9933 LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
9934 const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
9935 const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
9937 class C2Tuple_u32CVec_u8ZZ {
9939 LDKC2Tuple_u32CVec_u8ZZ self;
9941 C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
9942 C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
9943 C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
9944 operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
9945 ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
9946 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; }
9947 LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
9948 LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
9949 const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
9950 const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
9952 class CVec_C2Tuple_PublicKeyTypeZZ {
9954 LDKCVec_C2Tuple_PublicKeyTypeZZ self;
9956 CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
9957 CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
9958 CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
9959 operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
9960 ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
9961 CVec_C2Tuple_PublicKeyTypeZZ& operator=(CVec_C2Tuple_PublicKeyTypeZZ&& o) { CVec_C2Tuple_PublicKeyTypeZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); return *this; }
9962 LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
9963 LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
9964 const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
9965 const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
9967 class CResult_OnionMessagePathNoneZ {
9969 LDKCResult_OnionMessagePathNoneZ self;
9971 CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
9972 CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
9973 CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
9974 operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
9975 ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
9976 CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
9977 LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
9978 LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
9979 const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
9980 const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
9982 class CResult_RefundBolt12ParseErrorZ {
9984 LDKCResult_RefundBolt12ParseErrorZ self;
9986 CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
9987 CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
9988 CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
9989 operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
9990 ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
9991 CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
9992 LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
9993 LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
9994 const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
9995 const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
9997 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
9999 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
10001 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
10002 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10003 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10004 operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
10005 ~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
10006 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; }
10007 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
10008 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
10009 const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
10010 const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
10012 class CVec_C2Tuple_u64CVec_u8ZZZ {
10014 LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
10016 CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
10017 CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
10018 CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
10019 operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
10020 ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
10021 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; }
10022 LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
10023 LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
10024 const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
10025 const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
10027 class CResult_u32GraphSyncErrorZ {
10029 LDKCResult_u32GraphSyncErrorZ self;
10031 CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
10032 CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
10033 CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
10034 operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
10035 ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
10036 CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
10037 LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
10038 LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
10039 const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
10040 const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
10042 class CVec_PhantomRouteHintsZ {
10044 LDKCVec_PhantomRouteHintsZ self;
10046 CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
10047 CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
10048 CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
10049 operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
10050 ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
10051 CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
10052 LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
10053 LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
10054 const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
10055 const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
10057 class CResult_NoneAPIErrorZ {
10059 LDKCResult_NoneAPIErrorZ self;
10061 CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
10062 CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
10063 CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
10064 operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
10065 ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
10066 CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
10067 LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
10068 LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
10069 const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
10070 const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
10072 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
10074 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
10076 CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
10077 CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10078 CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10079 operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
10080 ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
10081 CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
10082 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10083 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10084 const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10085 const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10087 class COption_f64Z {
10089 LDKCOption_f64Z self;
10091 COption_f64Z(const COption_f64Z&) = delete;
10092 COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
10093 COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
10094 operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
10095 ~COption_f64Z() { COption_f64Z_free(self); }
10096 COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
10097 LDKCOption_f64Z* operator &() { return &self; }
10098 LDKCOption_f64Z* operator ->() { return &self; }
10099 const LDKCOption_f64Z* operator &() const { return &self; }
10100 const LDKCOption_f64Z* operator ->() const { return &self; }
10102 class CResult_ChannelDetailsDecodeErrorZ {
10104 LDKCResult_ChannelDetailsDecodeErrorZ self;
10106 CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
10107 CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
10108 CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
10109 operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
10110 ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
10111 CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
10112 LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
10113 LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
10114 const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
10115 const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
10117 class CVec_PublicKeyZ {
10119 LDKCVec_PublicKeyZ self;
10121 CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
10122 CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
10123 CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
10124 operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
10125 ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
10126 CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
10127 LDKCVec_PublicKeyZ* operator &() { return &self; }
10128 LDKCVec_PublicKeyZ* operator ->() { return &self; }
10129 const LDKCVec_PublicKeyZ* operator &() const { return &self; }
10130 const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
10132 class CVec_C2Tuple_usizeTransactionZZ {
10134 LDKCVec_C2Tuple_usizeTransactionZZ self;
10136 CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
10137 CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
10138 CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
10139 operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
10140 ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
10141 CVec_C2Tuple_usizeTransactionZZ& operator=(CVec_C2Tuple_usizeTransactionZZ&& o) { CVec_C2Tuple_usizeTransactionZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); return *this; }
10142 LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
10143 LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
10144 const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
10145 const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
10147 class CResult_TxRemoveInputDecodeErrorZ {
10149 LDKCResult_TxRemoveInputDecodeErrorZ self;
10151 CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
10152 CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
10153 CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
10154 operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
10155 ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
10156 CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
10157 LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
10158 LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
10159 const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
10160 const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
10162 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
10164 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
10166 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
10167 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10168 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10169 operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
10170 ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
10171 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; }
10172 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
10173 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
10174 const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
10175 const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
10177 class CResult_OffersMessageDecodeErrorZ {
10179 LDKCResult_OffersMessageDecodeErrorZ self;
10181 CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
10182 CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
10183 CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
10184 operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
10185 ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
10186 CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
10187 LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
10188 LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
10189 const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
10190 const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
10192 class C2Tuple_u64u64Z {
10194 LDKC2Tuple_u64u64Z self;
10196 C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
10197 C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
10198 C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
10199 operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
10200 ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
10201 C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
10202 LDKC2Tuple_u64u64Z* operator &() { return &self; }
10203 LDKC2Tuple_u64u64Z* operator ->() { return &self; }
10204 const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
10205 const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
10207 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
10209 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
10211 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
10212 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
10213 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
10214 operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
10215 ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
10216 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
10217 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
10218 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
10219 const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
10220 const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
10222 class CResult_RecipientOnionFieldsDecodeErrorZ {
10224 LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
10226 CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
10227 CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
10228 CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
10229 operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
10230 ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
10231 CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
10232 LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
10233 LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
10234 const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
10235 const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
10237 class C2Tuple_u32TxOutZ {
10239 LDKC2Tuple_u32TxOutZ self;
10241 C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
10242 C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
10243 C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
10244 operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
10245 ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
10246 C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
10247 LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
10248 LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
10249 const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
10250 const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
10254 LDKCVec_UtxoZ self;
10256 CVec_UtxoZ(const CVec_UtxoZ&) = delete;
10257 CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
10258 CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
10259 operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
10260 ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
10261 CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
10262 LDKCVec_UtxoZ* operator &() { return &self; }
10263 LDKCVec_UtxoZ* operator ->() { return &self; }
10264 const LDKCVec_UtxoZ* operator &() const { return &self; }
10265 const LDKCVec_UtxoZ* operator ->() const { return &self; }
10267 class CResult_ChannelConfigDecodeErrorZ {
10269 LDKCResult_ChannelConfigDecodeErrorZ self;
10271 CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
10272 CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
10273 CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
10274 operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
10275 ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
10276 CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
10277 LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
10278 LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
10279 const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
10280 const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
10282 class CVec_PrivateRouteZ {
10284 LDKCVec_PrivateRouteZ self;
10286 CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
10287 CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
10288 CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
10289 operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
10290 ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
10291 CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
10292 LDKCVec_PrivateRouteZ* operator &() { return &self; }
10293 LDKCVec_PrivateRouteZ* operator ->() { return &self; }
10294 const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
10295 const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
10297 class COption_i64Z {
10299 LDKCOption_i64Z self;
10301 COption_i64Z(const COption_i64Z&) = delete;
10302 COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
10303 COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
10304 operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
10305 ~COption_i64Z() { COption_i64Z_free(self); }
10306 COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
10307 LDKCOption_i64Z* operator &() { return &self; }
10308 LDKCOption_i64Z* operator ->() { return &self; }
10309 const LDKCOption_i64Z* operator &() const { return &self; }
10310 const LDKCOption_i64Z* operator ->() const { return &self; }
10312 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
10314 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
10316 C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
10317 C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
10318 C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
10319 operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
10320 ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
10321 C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
10322 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
10323 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
10324 const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
10325 const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
10327 class CResult_ShutdownDecodeErrorZ {
10329 LDKCResult_ShutdownDecodeErrorZ self;
10331 CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
10332 CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
10333 CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
10334 operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
10335 ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
10336 CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
10337 LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
10338 LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
10339 const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
10340 const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
10342 class C2Tuple_u64CVec_u8ZZ {
10344 LDKC2Tuple_u64CVec_u8ZZ self;
10346 C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
10347 C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
10348 C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
10349 operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
10350 ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
10351 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; }
10352 LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
10353 LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
10354 const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
10355 const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
10357 class CResult_OfferBolt12ParseErrorZ {
10359 LDKCResult_OfferBolt12ParseErrorZ self;
10361 CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
10362 CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
10363 CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
10364 operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
10365 ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
10366 CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
10367 LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
10368 LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
10369 const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
10370 const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
10372 class CResult_ThirtyTwoBytesRetryableSendFailureZ {
10374 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
10376 CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
10377 CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
10378 CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
10379 operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
10380 ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
10381 CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
10382 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
10383 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
10384 const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
10385 const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
10387 class CVec_MonitorEventZ {
10389 LDKCVec_MonitorEventZ self;
10391 CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
10392 CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
10393 CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
10394 operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
10395 ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
10396 CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
10397 LDKCVec_MonitorEventZ* operator &() { return &self; }
10398 LDKCVec_MonitorEventZ* operator ->() { return &self; }
10399 const LDKCVec_MonitorEventZ* operator &() const { return &self; }
10400 const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
10402 class CResult_BigSizeDecodeErrorZ {
10404 LDKCResult_BigSizeDecodeErrorZ self;
10406 CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
10407 CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
10408 CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
10409 operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
10410 ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
10411 CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
10412 LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
10413 LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
10414 const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
10415 const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
10417 class CResult_TxOutUtxoLookupErrorZ {
10419 LDKCResult_TxOutUtxoLookupErrorZ self;
10421 CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
10422 CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
10423 CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
10424 operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
10425 ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
10426 CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
10427 LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
10428 LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
10429 const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
10430 const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
10432 class CResult_BlindedPathNoneZ {
10434 LDKCResult_BlindedPathNoneZ self;
10436 CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
10437 CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
10438 CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
10439 operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
10440 ~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
10441 CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
10442 LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
10443 LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
10444 const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
10445 const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
10447 class COption_usizeZ {
10449 LDKCOption_usizeZ self;
10451 COption_usizeZ(const COption_usizeZ&) = delete;
10452 COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
10453 COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
10454 operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
10455 ~COption_usizeZ() { COption_usizeZ_free(self); }
10456 COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
10457 LDKCOption_usizeZ* operator &() { return &self; }
10458 LDKCOption_usizeZ* operator ->() { return &self; }
10459 const LDKCOption_usizeZ* operator &() const { return &self; }
10460 const LDKCOption_usizeZ* operator ->() const { return &self; }
10462 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
10464 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
10466 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
10467 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
10468 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
10469 operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
10470 ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
10471 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; }
10472 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
10473 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
10474 const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
10475 const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
10477 class CResult_NoneNoneZ {
10479 LDKCResult_NoneNoneZ self;
10481 CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
10482 CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
10483 CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
10484 operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
10485 ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
10486 CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
10487 LDKCResult_NoneNoneZ* operator &() { return &self; }
10488 LDKCResult_NoneNoneZ* operator ->() { return &self; }
10489 const LDKCResult_NoneNoneZ* operator &() const { return &self; }
10490 const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
10492 class CResult_boolPeerHandleErrorZ {
10494 LDKCResult_boolPeerHandleErrorZ self;
10496 CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
10497 CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
10498 CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
10499 operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
10500 ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
10501 CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
10502 LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
10503 LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
10504 const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
10505 const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
10507 class CResult_ChannelUpdateDecodeErrorZ {
10509 LDKCResult_ChannelUpdateDecodeErrorZ self;
10511 CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
10512 CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
10513 CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
10514 operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
10515 ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
10516 CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
10517 LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
10518 LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
10519 const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
10520 const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
10522 class CVec_APIErrorZ {
10524 LDKCVec_APIErrorZ self;
10526 CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
10527 CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
10528 CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
10529 operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
10530 ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
10531 CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
10532 LDKCVec_APIErrorZ* operator &() { return &self; }
10533 LDKCVec_APIErrorZ* operator ->() { return &self; }
10534 const LDKCVec_APIErrorZ* operator &() const { return &self; }
10535 const LDKCVec_APIErrorZ* operator ->() const { return &self; }
10537 class COption_TxOutZ {
10539 LDKCOption_TxOutZ self;
10541 COption_TxOutZ(const COption_TxOutZ&) = delete;
10542 COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
10543 COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
10544 operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
10545 ~COption_TxOutZ() { COption_TxOutZ_free(self); }
10546 COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
10547 LDKCOption_TxOutZ* operator &() { return &self; }
10548 LDKCOption_TxOutZ* operator ->() { return &self; }
10549 const LDKCOption_TxOutZ* operator &() const { return &self; }
10550 const LDKCOption_TxOutZ* operator ->() const { return &self; }
10552 class COption_ClosureReasonZ {
10554 LDKCOption_ClosureReasonZ self;
10556 COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
10557 COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
10558 COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
10559 operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
10560 ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
10561 COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
10562 LDKCOption_ClosureReasonZ* operator &() { return &self; }
10563 LDKCOption_ClosureReasonZ* operator ->() { return &self; }
10564 const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
10565 const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
10567 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
10569 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
10571 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
10572 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
10573 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
10574 operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
10575 ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
10576 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; }
10577 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
10578 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
10579 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
10580 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
10582 class CResult_TransactionU16LenLimitedDecodeErrorZ {
10584 LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
10586 CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
10587 CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
10588 CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
10589 operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
10590 ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
10591 CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
10592 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
10593 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
10594 const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
10595 const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
10597 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
10599 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
10601 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
10602 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
10603 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
10604 operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
10605 ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
10606 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; }
10607 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
10608 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
10609 const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
10610 const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
10612 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
10614 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
10616 CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
10617 CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
10618 CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
10619 operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
10620 ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
10621 CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
10622 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
10623 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
10624 const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
10625 const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
10627 class CResult_OpenChannelV2DecodeErrorZ {
10629 LDKCResult_OpenChannelV2DecodeErrorZ self;
10631 CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
10632 CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
10633 CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
10634 operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
10635 ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
10636 CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
10637 LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
10638 LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
10639 const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
10640 const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
10642 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
10644 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
10646 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
10647 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
10648 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
10649 operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
10650 ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
10651 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; }
10652 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
10653 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
10654 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
10655 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
10657 class C2Tuple_PublicKeyOnionMessageZ {
10659 LDKC2Tuple_PublicKeyOnionMessageZ self;
10661 C2Tuple_PublicKeyOnionMessageZ(const C2Tuple_PublicKeyOnionMessageZ&) = delete;
10662 C2Tuple_PublicKeyOnionMessageZ(C2Tuple_PublicKeyOnionMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); }
10663 C2Tuple_PublicKeyOnionMessageZ(LDKC2Tuple_PublicKeyOnionMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); }
10664 operator LDKC2Tuple_PublicKeyOnionMessageZ() && { LDKC2Tuple_PublicKeyOnionMessageZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyOnionMessageZ)); return res; }
10665 ~C2Tuple_PublicKeyOnionMessageZ() { C2Tuple_PublicKeyOnionMessageZ_free(self); }
10666 C2Tuple_PublicKeyOnionMessageZ& operator=(C2Tuple_PublicKeyOnionMessageZ&& o) { C2Tuple_PublicKeyOnionMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyOnionMessageZ)); return *this; }
10667 LDKC2Tuple_PublicKeyOnionMessageZ* operator &() { return &self; }
10668 LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() { return &self; }
10669 const LDKC2Tuple_PublicKeyOnionMessageZ* operator &() const { return &self; }
10670 const LDKC2Tuple_PublicKeyOnionMessageZ* operator ->() const { return &self; }
10672 class CResult_RouteDecodeErrorZ {
10674 LDKCResult_RouteDecodeErrorZ self;
10676 CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
10677 CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
10678 CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
10679 operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
10680 ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
10681 CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
10682 LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
10683 LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
10684 const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
10685 const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
10687 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
10689 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
10691 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
10692 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
10693 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
10694 operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
10695 ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
10696 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; }
10697 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
10698 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
10699 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
10700 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
10702 class COption_NoneZ {
10704 LDKCOption_NoneZ self;
10706 COption_NoneZ(const COption_NoneZ&) = delete;
10707 COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
10708 COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
10709 operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
10710 ~COption_NoneZ() { COption_NoneZ_free(self); }
10711 COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
10712 LDKCOption_NoneZ* operator &() { return &self; }
10713 LDKCOption_NoneZ* operator ->() { return &self; }
10714 const LDKCOption_NoneZ* operator &() const { return &self; }
10715 const LDKCOption_NoneZ* operator ->() const { return &self; }
10717 class CResult_TxAddOutputDecodeErrorZ {
10719 LDKCResult_TxAddOutputDecodeErrorZ self;
10721 CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
10722 CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
10723 CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
10724 operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
10725 ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
10726 CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
10727 LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
10728 LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
10729 const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
10730 const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
10732 class COption_CVec_u8ZZ {
10734 LDKCOption_CVec_u8ZZ self;
10736 COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
10737 COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
10738 COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
10739 operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
10740 ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
10741 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; }
10742 LDKCOption_CVec_u8ZZ* operator &() { return &self; }
10743 LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
10744 const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
10745 const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
10748 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
10749 LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
10752 inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
10753 LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
10756 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
10757 LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, preimages);
10760 inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
10761 LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
10764 inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
10765 (self.provide_channel_parameters)(self.this_arg, channel_parameters);
10767 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ preimages) {
10768 LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, preimages);
10771 inline LDK::CResult_NoneNoneZ EcdsaChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
10772 LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
10775 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_holder_commitment_and_htlcs(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
10776 LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_holder_commitment_and_htlcs)(self.this_arg, commitment_tx);
10779 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]) {
10780 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
10783 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) {
10784 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
10787 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
10788 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
10791 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) {
10792 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
10795 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
10796 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
10799 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
10800 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
10803 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
10804 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
10807 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
10808 LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
10811 inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
10812 LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
10815 inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
10816 LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
10819 inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
10820 LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
10823 inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
10824 LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
10827 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
10828 LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
10831 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
10832 LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
10835 inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
10836 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
10839 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
10840 LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
10843 inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
10844 LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
10847 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
10848 LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
10851 inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script() {
10852 LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg);
10855 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
10856 LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
10859 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) {
10860 LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
10863 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) {
10864 LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
10867 inline uint64_t ScoreLookUp::channel_penalty_msat(uint64_t short_channel_id, const struct LDKNodeId *NONNULL_PTR source, const struct LDKNodeId *NONNULL_PTR target, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
10868 uint64_t ret = (self.channel_penalty_msat)(self.this_arg, short_channel_id, source, target, usage, score_params);
10871 inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
10872 (self.payment_path_failed)(self.this_arg, path, short_channel_id);
10874 inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path) {
10875 (self.payment_path_successful)(self.this_arg, path);
10877 inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id) {
10878 (self.probe_failed)(self.this_arg, path, short_channel_id);
10880 inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path) {
10881 (self.probe_successful)(self.this_arg, path);
10883 inline LDK::ScoreLookUp LockableScore::read_lock() {
10884 LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
10887 inline LDK::ScoreUpdate LockableScore::write_lock() {
10888 LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
10891 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
10892 (self.filtered_block_connected)(self.this_arg, header, txdata, height);
10894 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
10895 (self.block_connected)(self.this_arg, block, height);
10897 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
10898 (self.block_disconnected)(self.this_arg, header, height);
10900 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
10901 (self.transactions_confirmed)(self.this_arg, header, txdata, height);
10903 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
10904 (self.transaction_unconfirmed)(self.this_arg, txid);
10906 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
10907 (self.best_block_updated)(self.this_arg, header, height);
10909 inline LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
10910 LDK::CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
10913 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
10914 LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
10917 inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
10918 LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
10921 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
10922 LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
10925 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
10926 (self.register_tx)(self.this_arg, txid, script_pubkey);
10928 inline void Filter::register_output(struct LDKWatchedOutput output) {
10929 (self.register_output)(self.this_arg, output);
10931 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) {
10932 LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
10935 inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_tx(struct LDKTransaction tx) {
10936 LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
10939 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
10940 LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
10943 inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
10944 LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
10947 inline LDK::CResult_TransactionNoneZ WalletSource::sign_tx(struct LDKTransaction tx) {
10948 LDK::CResult_TransactionNoneZ ret = (self.sign_tx)(self.this_arg, tx);
10951 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
10952 LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
10955 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
10956 LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
10959 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
10960 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
10963 inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
10964 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
10967 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
10968 uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
10971 inline void SocketDescriptor::disconnect_socket() {
10972 (self.disconnect_socket)(self.this_arg);
10974 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
10975 bool ret = (self.eq)(self.this_arg, other_arg);
10978 inline uint64_t SocketDescriptor::hash() {
10979 uint64_t ret = (self.hash)(self.this_arg);
10982 inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
10983 LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
10986 inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
10987 LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
10990 inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
10991 LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
10994 inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
10995 LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
10998 inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
10999 LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
11002 inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
11003 LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
11006 inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
11007 LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
11010 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
11011 (self.handle_open_channel)(self.this_arg, their_node_id, msg);
11013 inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
11014 (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
11016 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
11017 (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
11019 inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
11020 (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
11022 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
11023 (self.handle_funding_created)(self.this_arg, their_node_id, msg);
11025 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
11026 (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
11028 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
11029 (self.handle_channel_ready)(self.this_arg, their_node_id, msg);
11031 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
11032 (self.handle_shutdown)(self.this_arg, their_node_id, msg);
11034 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
11035 (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
11037 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
11038 (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
11040 inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
11041 (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
11043 inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
11044 (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
11046 inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
11047 (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
11049 inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
11050 (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
11052 inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
11053 (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
11055 inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
11056 (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
11058 inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
11059 (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
11061 inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
11062 (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
11064 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
11065 (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
11067 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
11068 (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
11070 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
11071 (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
11073 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
11074 (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
11076 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
11077 (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
11079 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
11080 (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
11082 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
11083 (self.handle_update_fee)(self.this_arg, their_node_id, msg);
11085 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
11086 (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
11088 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11089 (self.peer_disconnected)(self.this_arg, their_node_id);
11091 inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
11092 LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
11095 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
11096 (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
11098 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
11099 (self.handle_channel_update)(self.this_arg, their_node_id, msg);
11101 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
11102 (self.handle_error)(self.this_arg, their_node_id, msg);
11104 inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
11105 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11108 inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11109 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11112 inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_genesis_hashes() {
11113 LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_genesis_hashes)(self.this_arg);
11116 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
11117 LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
11120 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
11121 LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
11124 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
11125 LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
11128 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
11129 LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
11132 inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
11133 LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
11136 inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
11137 LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
11140 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
11141 LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
11144 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
11145 LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
11148 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
11149 LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
11152 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
11153 LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
11156 inline bool RoutingMessageHandler::processing_queue_high() {
11157 bool ret = (self.processing_queue_high)(self.this_arg);
11160 inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
11161 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11164 inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11165 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11168 inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
11169 (self.handle_onion_message)(self.this_arg, peer_node_id, msg);
11171 inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
11172 LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
11175 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11176 (self.peer_disconnected)(self.this_arg, their_node_id);
11178 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
11179 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11182 inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11183 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11186 inline void Logger::log(const struct LDKRecord *NONNULL_PTR record) {
11187 (self.log)(self.this_arg, record);
11189 inline void FutureCallback::call() {
11190 (self.call)(self.this_arg);
11192 inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
11193 LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
11196 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
11197 (self.broadcast_transactions)(self.this_arg, txs);
11199 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
11200 uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
11203 inline uint64_t CustomOnionMessageContents::tlv_type() {
11204 uint64_t ret = (self.tlv_type)(self.this_arg);
11207 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
11208 LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
11211 inline LDK::OnionMessage OnionMessageProvider::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
11212 LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
11215 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
11216 (self.process_pending_events)(self.this_arg, handler);
11218 inline void EventHandler::handle_event(struct LDKEvent event) {
11219 (self.handle_event)(self.this_arg, event);
11221 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
11222 LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
11225 inline uint16_t Type::type_id() {
11226 uint16_t ret = (self.type_id)(self.this_arg);
11229 inline LDK::Str Type::debug_str() {
11230 LDK::Str ret = (self.debug_str)(self.this_arg);
11233 inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*genesis_hash)[32], uint64_t short_channel_id) {
11234 LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, genesis_hash, short_channel_id);
11237 inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
11238 LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
11241 inline LDK::COption_CustomOnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKCustomOnionMessageContents msg) {
11242 LDK::COption_CustomOnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
11245 inline LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
11246 LDK::CResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
11249 inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
11250 LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
11253 inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
11254 LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);