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;
17 class ChannelDerivationParameters;
26 class PhantomKeysManager;
27 class BackgroundProcessor;
31 class ScorerAccountingForInFlightHtlcs;
37 class RouteParameters;
38 class PaymentParameters;
42 class FirstHopCandidate;
43 class PublicHopCandidate;
44 class PrivateHopCandidate;
45 class BlindedPathCandidate;
46 class OneHopBlindedPathCandidate;
47 class CandidateRouteHop;
53 class MultiThreadedLockableScore;
54 class MultiThreadedScoreLockRead;
55 class MultiThreadedScoreLockWrite;
57 class FixedPenaltyScorer;
58 class ProbabilisticScorer;
59 class ProbabilisticScoringFeeParameters;
60 class ProbabilisticScoringDecayParameters;
64 class ChannelMonitorUpdateStatus;
70 class ChannelFeatures;
71 class Bolt11InvoiceFeatures;
73 class InvoiceRequestFeatures;
74 class Bolt12InvoiceFeatures;
75 class BlindedHopFeatures;
76 class ChannelTypeFeatures;
82 class ReadOnlyNetworkGraph;
85 class ChannelUpdateInfo;
87 class DirectedChannelInfo;
88 class EffectiveCapacity;
90 class NodeAnnouncementInfo;
94 class AnchorDescriptor;
95 class BumpTransactionEvent;
99 class CoinSelectionSource;
102 class BumpTransactionEventHandler;
103 class PendingHTLCRouting;
104 class BlindedForward;
105 class PendingHTLCInfo;
106 class BlindedFailure;
108 class ChannelManager;
109 class ChainParameters;
110 class CounterpartyForwardingInfo;
111 class ChannelCounterparty;
112 class ChannelDetails;
113 class ChannelShutdownState;
114 class RecentPaymentDetails;
115 class PhantomRouteHints;
116 class ChannelManagerReadArgs;
117 class ChannelHandshakeConfig;
118 class ChannelHandshakeLimits;
119 class MaxDustHTLCExposure;
121 class ChannelConfigUpdate;
125 class EcdsaChannelSigner;
126 class WriteableEcdsaChannelSigner;
127 class ChannelMonitorUpdate;
131 class ChannelMonitor;
133 class CustomMessageHandler;
134 class IgnoringMessageHandler;
135 class ErroringMessageHandler;
136 class MessageHandler;
137 class SocketDescriptor;
138 class PeerHandleError;
140 class GraphSyncError;
141 class RapidGossipSync;
144 class MonitorUpdatingPersister;
145 class UnsignedInvoiceRequest;
146 class InvoiceRequest;
147 class VerifiedInvoiceRequest;
151 class WarningMessage;
157 class AcceptChannelV2;
158 class FundingCreated;
168 class TxRemoveOutput;
175 class ClosingSignedFeeRange;
179 class UpdateFulfillHTLC;
180 class UpdateFailHTLC;
181 class UpdateFailMalformedHTLC;
182 class CommitmentSigned;
185 class ChannelReestablish;
186 class AnnouncementSignatures;
188 class SocketAddressParseError;
189 class UnsignedGossipMessage;
190 class UnsignedNodeAnnouncement;
191 class NodeAnnouncement;
192 class UnsignedChannelAnnouncement;
193 class ChannelAnnouncement;
194 class UnsignedChannelUpdate;
196 class QueryChannelRange;
197 class ReplyChannelRange;
198 class QueryShortChannelIds;
199 class ReplyShortChannelIdsEnd;
200 class GossipTimestampFilter;
202 class LightningError;
203 class CommitmentUpdate;
204 class ChannelMessageHandler;
205 class RoutingMessageHandler;
206 class OnionMessageHandler;
207 class FinalOnionHopData;
212 class FutureCallback;
215 class OffersMessageHandler;
218 class CounterpartyCommitmentSecrets;
219 class TxCreationKeys;
220 class ChannelPublicKeys;
221 class HTLCOutputInCommitment;
222 class ChannelTransactionParameters;
223 class CounterpartyChannelTransactionParameters;
224 class DirectedChannelTransactionParameters;
225 class HolderCommitmentTransaction;
226 class BuiltCommitmentTransaction;
227 class ClosingTransaction;
228 class TrustedClosingTransaction;
229 class CommitmentTransaction;
230 class TrustedCommitmentTransaction;
231 class ShutdownScript;
232 class InvalidShutdownScript;
233 class Bolt12ParseError;
234 class Bolt12SemanticError;
235 class BroadcasterInterface;
236 class ConfirmationTarget;
239 class ParsedOnionMessageContents;
240 class OnionMessageContents;
241 class PaymentPurpose;
245 class HTLCDestination;
246 class PaymentFailureReason;
248 class MessageSendEvent;
249 class MessageSendEventsProvider;
250 class EventsProvider;
252 class Bolt11ParseError;
253 class ParseOrSemanticError;
255 class SignedRawBolt11Invoice;
256 class RawBolt11Invoice;
258 class PositiveTimestamp;
265 class MinFinalCltvExpiryDelta;
267 class Bolt11InvoiceSignature;
270 class Bolt11SemanticError;
271 class SignOrCreationError;
275 class TransactionU16LenLimited;
276 class UntrustedString;
277 class PrintableString;
278 class CustomMessageReader;
284 class PaymentConstraints;
285 class UtxoLookupError;
289 class OnionMessenger;
291 class DefaultMessageRouter;
292 class OnionMessagePath;
296 class CustomOnionMessageHandler;
298 class FilesystemStore;
302 class ErroneousField;
303 class DelayedPaymentBasepoint;
304 class DelayedPaymentKey;
307 class RevocationBasepoint;
309 class MonitorUpdateId;
311 class LockedChannelMonitor;
313 class CResult_HtlcKeyDecodeErrorZ;
314 class CResult_TransactionU16LenLimitedNoneZ;
315 class CResult_LockedChannelMonitorNoneZ;
316 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ;
317 class CResult_PhantomRouteHintsDecodeErrorZ;
318 class CResult_FundingCreatedDecodeErrorZ;
319 class CVec_C2Tuple_u32TxOutZZ;
320 class CResult_RetryDecodeErrorZ;
321 class CResult_BlindedForwardDecodeErrorZ;
322 class CResult_ChannelInfoDecodeErrorZ;
323 class COption_MaxDustHTLCExposureZ;
324 class COption_OffersMessageZ;
325 class CResult_CVec_u8ZPeerHandleErrorZ;
326 class COption_NetworkUpdateZ;
328 class CResult_OnionPacketDecodeErrorZ;
329 class CResult_GossipTimestampFilterDecodeErrorZ;
330 class CResult_RouteHintDecodeErrorZ;
331 class COption_FilterZ;
332 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ;
333 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ;
334 class CResult_COption_APIErrorZDecodeErrorZ;
335 class CVec_UpdateAddHTLCZ;
336 class CResult_TxAbortDecodeErrorZ;
337 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ;
339 class CResult_RecipientOnionFieldsNoneZ;
340 class C2Tuple__u1632_u1632Z;
341 class CResult_CVec_StrZIOErrorZ;
342 class CResult_ClosingSignedFeeRangeDecodeErrorZ;
343 class CResult_TransactionNoneZ;
344 class CResult_CommitmentSignedDecodeErrorZ;
345 class CResult_CommitmentTransactionDecodeErrorZ;
346 class CResult_StfuDecodeErrorZ;
347 class CResult_OpenChannelDecodeErrorZ;
348 class CResult_ErrorMessageDecodeErrorZ;
349 class COption_APIErrorZ;
350 class CResult_QueryChannelRangeDecodeErrorZ;
351 class CVec_TransactionZ;
353 class CResult_ChannelFeaturesDecodeErrorZ;
354 class CResult_ChannelReadyDecodeErrorZ;
355 class CResult_RevocationBasepointDecodeErrorZ;
356 class CResult_UpdateFeeDecodeErrorZ;
357 class CResult_NoneBolt11SemanticErrorZ;
358 class COption_OnionMessageContentsZ;
359 class CResult_NoneRetryableSendFailureZ;
360 class CResult_boolLightningErrorZ;
361 class CResult_NodeIdDecodeErrorZ;
362 class CResult_ChannelShutdownStateDecodeErrorZ;
363 class CResult_HTLCOutputInCommitmentDecodeErrorZ;
364 class CResult_NodeAnnouncementInfoDecodeErrorZ;
365 class CResult_ShutdownScriptInvalidShutdownScriptZ;
366 class CResult_COption_NetworkUpdateZDecodeErrorZ;
367 class CVec_UpdateFailMalformedHTLCZ;
368 class CResult_ShutdownScriptNoneZ;
369 class CResult_PendingHTLCInfoInboundHTLCErrZ;
370 class CResult_PendingHTLCInfoDecodeErrorZ;
371 class COption_HTLCDestinationZ;
372 class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ;
373 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ;
374 class CVec_RouteHopZ;
375 class C2Tuple_PublicKeyCVec_SocketAddressZZ;
376 class CResult_CVec_UtxoZNoneZ;
377 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ;
378 class CResult_CVec_u8ZIOErrorZ;
379 class C3Tuple_OffersMessageDestinationBlindedPathZ;
380 class CVec_ThirtyTwoBytesZ;
381 class CResult_ChannelMonitorUpdateStatusNoneZ;
382 class CResult_ClosingSignedDecodeErrorZ;
383 class CVec_CResult_NoneAPIErrorZZ;
384 class CResult_SchnorrSignatureNoneZ;
385 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ;
386 class CResult_HTLCDescriptorDecodeErrorZ;
387 class CVec_RecentPaymentDetailsZ;
388 class CVec_RouteHintHopZ;
389 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ;
390 class CResult_UntrustedStringDecodeErrorZ;
391 class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ;
393 class CResult_PaymentParametersDecodeErrorZ;
394 class C2Tuple_ThirtyTwoBytesChannelMonitorZ;
396 class CResult_DelayedPaymentBasepointDecodeErrorZ;
397 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ;
398 class CResult_TxAckRbfDecodeErrorZ;
399 class CResult_Bolt11InvoiceBolt11SemanticErrorZ;
400 class COption_UtxoLookupZ;
401 class CResult_PongDecodeErrorZ;
402 class CResult_UnsignedChannelAnnouncementDecodeErrorZ;
403 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ;
404 class CResult_CVec_u8ZNoneZ;
405 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ;
406 class CResult_ChannelTransactionParametersDecodeErrorZ;
407 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ;
408 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ;
409 class CResult_InFlightHtlcsDecodeErrorZ;
410 class CResult_COption_HTLCDestinationZDecodeErrorZ;
411 class CResult_ThirtyTwoBytesNoneZ;
412 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ;
413 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ;
414 class CResult_SendSuccessSendErrorZ;
415 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ;
416 class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ;
417 class CResult_BlindedHopDecodeErrorZ;
418 class CResult_NoneLightningErrorZ;
419 class CResult_FixedPenaltyScorerDecodeErrorZ;
420 class CVec_BlindedPathZ;
421 class CResult_NonePeerHandleErrorZ;
422 class CResult_FinalOnionHopDataDecodeErrorZ;
423 class CResult_TrustedCommitmentTransactionNoneZ;
424 class CResult_COption_EventZDecodeErrorZ;
425 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ;
426 class CResult_PaymentFailureReasonDecodeErrorZ;
427 class COption_SocketAddressZ;
428 class CResult_COption_MonitorEventZDecodeErrorZ;
429 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ;
430 class CResult_DescriptionCreationErrorZ;
431 class CResult_RoutingFeesDecodeErrorZ;
432 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ;
433 class CResult_PaymentRelayDecodeErrorZ;
434 class CResult_QueryShortChannelIdsDecodeErrorZ;
435 class CResult_VerifiedInvoiceRequestNoneZ;
436 class CResult_UpdateAddHTLCDecodeErrorZ;
437 class COption_MonitorEventZ;
439 class CResult_COption_TypeZDecodeErrorZ;
440 class CResult_COption_PathFailureZDecodeErrorZ;
441 class CResult_Bolt11InvoiceSignOrCreationErrorZ;
442 class CResult_UpdateFailHTLCDecodeErrorZ;
443 class CResult_CVec_BlindedPathZNoneZ;
444 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ;
445 class CResult_RevokeAndACKDecodeErrorZ;
446 class CResult_SpendableOutputDescriptorDecodeErrorZ;
447 class C2Tuple_PublicKeyCOption_SocketAddressZZ;
448 class CResult_UnsignedChannelUpdateDecodeErrorZ;
449 class CResult_PayeePubKeySecp256k1ErrorZ;
450 class C2Tuple__u832u16Z;
451 class COption_BigEndianScalarZ;
452 class CResult_PublicKeySecp256k1ErrorZ;
453 class CResult_CVec_ECDSASignatureZNoneZ;
454 class CVec_BlindedHopZ;
455 class CResult_COption_ClosureReasonZDecodeErrorZ;
456 class CResult_InvoiceErrorDecodeErrorZ;
457 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ;
458 class CResult_RouteParametersDecodeErrorZ;
459 class CResult_PrivateRouteCreationErrorZ;
460 class CResult_NodeAliasDecodeErrorZ;
461 class CVec_UpdateFulfillHTLCZ;
462 class CVec_C2Tuple_u32CVec_u8ZZZ;
463 class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ;
464 class CResult_AnnouncementSignaturesDecodeErrorZ;
465 class CResult_TxCompleteDecodeErrorZ;
466 class CResult_UpdateFulfillHTLCDecodeErrorZ;
467 class CResult_NodeFeaturesDecodeErrorZ;
468 class CResult_InMemorySignerDecodeErrorZ;
469 class CResult_TxSignaturesDecodeErrorZ;
470 class CVec_HTLCDescriptorZ;
471 class CResult_ReplyShortChannelIdsEndDecodeErrorZ;
472 class COption_PathFailureZ;
473 class CResult_StrSecp256k1ErrorZ;
474 class CVec_ECDSASignatureZ;
475 class CResult_ChannelUpdateInfoDecodeErrorZ;
476 class CVec_UpdateFailHTLCZ;
478 class CResult_BuiltCommitmentTransactionDecodeErrorZ;
479 class CVec_SpendableOutputDescriptorZ;
480 class C2Tuple_OutPointCVec_u8ZZ;
481 class CResult_WitnessNoneZ;
482 class COption_C2Tuple_u64u64ZZ;
483 class CResult_ChannelAnnouncementDecodeErrorZ;
484 class CResult_HTLCUpdateDecodeErrorZ;
485 class CResult_TxAddInputDecodeErrorZ;
486 class CResult_PeeledOnionNoneZ;
487 class CResult_TxInitRbfDecodeErrorZ;
488 class COption_WriteableScoreZ;
490 class CVec_OutPointZ;
491 class CResult_SpliceAckDecodeErrorZ;
492 class CResult_PositiveTimestampCreationErrorZ;
493 class CResult_ChannelMonitorUpdateDecodeErrorZ;
494 class C2Tuple_BlindedPayInfoBlindedPathZ;
495 class CResult_ReplyChannelRangeDecodeErrorZ;
496 class CResult_UnsignedNodeAnnouncementDecodeErrorZ;
497 class CResult_TrustedClosingTransactionNoneZ;
498 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ;
499 class C2Tuple_PublicKeyTypeZ;
500 class CResult_TxRemoveOutputDecodeErrorZ;
501 class CResult_ChannelReestablishDecodeErrorZ;
502 class CResult_OnionMessageDecodeErrorZ;
503 class CResult_Bolt11InvoiceParseOrSemanticErrorZ;
504 class CResult_InitFeaturesDecodeErrorZ;
505 class CResult_PublicKeyNoneZ;
506 class CResult_PingDecodeErrorZ;
507 class CResult_RevocationKeyDecodeErrorZ;
508 class CResult_BlindedHopFeaturesDecodeErrorZ;
509 class CVec_TransactionOutputsZ;
510 class COption_HTLCClaimZ;
512 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ;
513 class CResult_ProbabilisticScorerDecodeErrorZ;
515 class CResult_ShutdownScriptDecodeErrorZ;
516 class CResult_SiPrefixBolt11ParseErrorZ;
517 class C2Tuple_usizeTransactionZ;
518 class CResult_NodeAnnouncementDecodeErrorZ;
520 class CVec_ChannelMonitorZ;
521 class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ;
522 class CResult_AcceptChannelV2DecodeErrorZ;
523 class CResult_RouteHopDecodeErrorZ;
524 class CVec_HTLCOutputInCommitmentZ;
525 class CResult_CoinSelectionNoneZ;
526 class C2Tuple_ThirtyTwoBytesPublicKeyZ;
527 class CResult_TxCreationKeysDecodeErrorZ;
528 class CResult_BlindedPathDecodeErrorZ;
530 class CResult_NoneIOErrorZ;
531 class CResult_MaxDustHTLCExposureDecodeErrorZ;
532 class CVec_CommitmentTransactionZ;
533 class CResult_FundingSignedDecodeErrorZ;
534 class CResult_RecoverableSignatureNoneZ;
535 class CResult_SocketAddressDecodeErrorZ;
537 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ;
539 class CResult_NetworkGraphDecodeErrorZ;
540 class CResult_NodeInfoDecodeErrorZ;
543 class CResult_RouteLightningErrorZ;
544 class CResult_NonePaymentSendFailureZ;
545 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ;
546 class CResult_ChannelPublicKeysDecodeErrorZ;
547 class CVec_ClaimedHTLCZ;
548 class COption_CVec_ThirtyTwoBytesZZ;
549 class CVec_SocketAddressZ;
550 class CResult_ThirtyTwoBytesPaymentSendFailureZ;
551 class CResult_HolderCommitmentTransactionDecodeErrorZ;
552 class CResult_WarningMessageDecodeErrorZ;
553 class CResult_ChannelCounterpartyDecodeErrorZ;
554 class CVec_ForwardNodeZ;
555 class CResult_DelayedPaymentKeyDecodeErrorZ;
556 class CResult_InitDecodeErrorZ;
557 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ;
558 class CResult_SpliceDecodeErrorZ;
559 class CResult_PaymentPurposeDecodeErrorZ;
560 class CResult_ClaimedHTLCDecodeErrorZ;
561 class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ;
562 class CResult_OutPointDecodeErrorZ;
563 class CVec_ChannelDetailsZ;
564 class CVec_MonitorUpdateIdZ;
565 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ;
566 class CVec_MessageSendEventZ;
567 class CResult_RouteHintHopDecodeErrorZ;
568 class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ;
569 class CResult_UpdateFailMalformedHTLCDecodeErrorZ;
570 class CResult_BlindedPayInfoDecodeErrorZ;
571 class CResult_ThirtyTwoBytesAPIErrorZ;
572 class COption_ChannelShutdownStateZ;
573 class CResult_AcceptChannelDecodeErrorZ;
574 class CResult_HostnameDecodeErrorZ;
575 class C2Tuple_u64u16Z;
576 class COption_ThirtyTwoBytesZ;
578 class CResult_NoneBolt12SemanticErrorZ;
579 class COption_SecretKeyZ;
580 class CResult_C2Tuple_CVec_u8Zu64ZNoneZ;
581 class COption_EventZ;
582 class CResult_ChannelTypeFeaturesDecodeErrorZ;
583 class COption_CVec_SocketAddressZZ;
584 class CVec_RouteHintZ;
586 class COption_PaymentFailureReasonZ;
587 class CResult_ECDSASignatureNoneZ;
588 class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ;
590 class CResult_BlindedTailDecodeErrorZ;
591 class CResult_SocketAddressSocketAddressParseErrorZ;
592 class COption_C2Tuple_u64u16ZZ;
593 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ;
594 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ;
595 class CResult_ChannelDerivationParametersDecodeErrorZ;
596 class CResult_PaymentConstraintsDecodeErrorZ;
597 class CResult_OnionMessagePathNoneZ;
598 class C2Tuple_u32CVec_u8ZZ;
599 class CVec_C2Tuple_PublicKeyTypeZZ;
600 class CResult_RefundBolt12ParseErrorZ;
601 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ;
602 class CVec_C2Tuple_u64CVec_u8ZZZ;
603 class CResult_u32GraphSyncErrorZ;
604 class CVec_PhantomRouteHintsZ;
605 class CResult_NoneAPIErrorZ;
606 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ;
608 class CResult_ChannelDetailsDecodeErrorZ;
609 class CVec_PublicKeyZ;
610 class C2Tuple_CVec_u8Zu64Z;
611 class CVec_C2Tuple_usizeTransactionZZ;
612 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ;
613 class CResult_PendingHTLCRoutingDecodeErrorZ;
614 class C2Tuple_u64u64Z;
615 class CResult_TxRemoveInputDecodeErrorZ;
616 class CResult_OffersMessageDecodeErrorZ;
617 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ;
618 class CResult_RecipientOnionFieldsDecodeErrorZ;
619 class C2Tuple_u32TxOutZ;
621 class CResult_ChannelConfigDecodeErrorZ;
622 class CVec_PrivateRouteZ;
624 class C2Tuple_ThirtyTwoBytesChannelManagerZ;
625 class CResult_COption_OnionMessageContentsZDecodeErrorZ;
626 class C2Tuple_u64CVec_u8ZZ;
627 class CResult_OfferBolt12ParseErrorZ;
628 class CResult_ThirtyTwoBytesRetryableSendFailureZ;
629 class CVec_MonitorEventZ;
630 class CResult_ShutdownDecodeErrorZ;
631 class CResult_BigSizeDecodeErrorZ;
632 class CResult_TxOutUtxoLookupErrorZ;
633 class CResult_BlindedPathNoneZ;
634 class COption_usizeZ;
635 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ;
636 class CResult_NoneNoneZ;
637 class CResult_boolPeerHandleErrorZ;
638 class CResult_ChannelUpdateDecodeErrorZ;
639 class CVec_APIErrorZ;
640 class COption_TxOutZ;
641 class COption_ClosureReasonZ;
642 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ;
643 class CResult_TransactionU16LenLimitedDecodeErrorZ;
644 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ;
645 class CResult_CounterpartyForwardingInfoDecodeErrorZ;
646 class CResult_OpenChannelV2DecodeErrorZ;
647 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ;
648 class CResult_HtlcBasepointDecodeErrorZ;
649 class CResult_SpliceLockedDecodeErrorZ;
650 class CResult_RouteDecodeErrorZ;
651 class CResult_BlindedFailureDecodeErrorZ;
652 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ;
654 class CResult_TxAddOutputDecodeErrorZ;
655 class COption_CVec_u8ZZ;
661 Str(const Str&) = delete;
662 Str(Str&& o) : self(o.self) { memset(&o, 0, sizeof(Str)); }
663 Str(LDKStr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStr)); }
664 operator LDKStr() && { LDKStr res = self; memset(&self, 0, sizeof(LDKStr)); return res; }
665 ~Str() { Str_free(self); }
666 Str& operator=(Str&& o) { Str_free(self); self = o.self; memset(&o, 0, sizeof(Str)); return *this; }
667 LDKStr* operator &() { return &self; }
668 LDKStr* operator ->() { return &self; }
669 const LDKStr* operator &() const { return &self; }
670 const LDKStr* operator ->() const { return &self; }
676 Refund(const Refund&) = delete;
677 Refund(Refund&& o) : self(o.self) { memset(&o, 0, sizeof(Refund)); }
678 Refund(LDKRefund&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRefund)); }
679 operator LDKRefund() && { LDKRefund res = self; memset(&self, 0, sizeof(LDKRefund)); return res; }
680 ~Refund() { Refund_free(self); }
681 Refund& operator=(Refund&& o) { Refund_free(self); self = o.self; memset(&o, 0, sizeof(Refund)); return *this; }
682 LDKRefund* operator &() { return &self; }
683 LDKRefund* operator ->() { return &self; }
684 const LDKRefund* operator &() const { return &self; }
685 const LDKRefund* operator ->() const { return &self; }
691 Retry(const Retry&) = delete;
692 Retry(Retry&& o) : self(o.self) { memset(&o, 0, sizeof(Retry)); }
693 Retry(LDKRetry&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetry)); }
694 operator LDKRetry() && { LDKRetry res = self; memset(&self, 0, sizeof(LDKRetry)); return res; }
695 ~Retry() { Retry_free(self); }
696 Retry& operator=(Retry&& o) { Retry_free(self); self = o.self; memset(&o, 0, sizeof(Retry)); return *this; }
697 LDKRetry* operator &() { return &self; }
698 LDKRetry* operator ->() { return &self; }
699 const LDKRetry* operator &() const { return &self; }
700 const LDKRetry* operator ->() const { return &self; }
702 class RetryableSendFailure {
704 LDKRetryableSendFailure self;
706 RetryableSendFailure(const RetryableSendFailure&) = delete;
707 RetryableSendFailure(RetryableSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(RetryableSendFailure)); }
708 RetryableSendFailure(LDKRetryableSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRetryableSendFailure)); }
709 operator LDKRetryableSendFailure() && { LDKRetryableSendFailure res = self; memset(&self, 0, sizeof(LDKRetryableSendFailure)); return res; }
710 RetryableSendFailure& operator=(RetryableSendFailure&& o) { self = o.self; memset(&o, 0, sizeof(RetryableSendFailure)); return *this; }
711 LDKRetryableSendFailure* operator &() { return &self; }
712 LDKRetryableSendFailure* operator ->() { return &self; }
713 const LDKRetryableSendFailure* operator &() const { return &self; }
714 const LDKRetryableSendFailure* operator ->() const { return &self; }
716 class PaymentSendFailure {
718 LDKPaymentSendFailure self;
720 PaymentSendFailure(const PaymentSendFailure&) = delete;
721 PaymentSendFailure(PaymentSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentSendFailure)); }
722 PaymentSendFailure(LDKPaymentSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentSendFailure)); }
723 operator LDKPaymentSendFailure() && { LDKPaymentSendFailure res = self; memset(&self, 0, sizeof(LDKPaymentSendFailure)); return res; }
724 ~PaymentSendFailure() { PaymentSendFailure_free(self); }
725 PaymentSendFailure& operator=(PaymentSendFailure&& o) { PaymentSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(PaymentSendFailure)); return *this; }
726 LDKPaymentSendFailure* operator &() { return &self; }
727 LDKPaymentSendFailure* operator ->() { return &self; }
728 const LDKPaymentSendFailure* operator &() const { return &self; }
729 const LDKPaymentSendFailure* operator ->() const { return &self; }
731 class ProbeSendFailure {
733 LDKProbeSendFailure self;
735 ProbeSendFailure(const ProbeSendFailure&) = delete;
736 ProbeSendFailure(ProbeSendFailure&& o) : self(o.self) { memset(&o, 0, sizeof(ProbeSendFailure)); }
737 ProbeSendFailure(LDKProbeSendFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbeSendFailure)); }
738 operator LDKProbeSendFailure() && { LDKProbeSendFailure res = self; memset(&self, 0, sizeof(LDKProbeSendFailure)); return res; }
739 ~ProbeSendFailure() { ProbeSendFailure_free(self); }
740 ProbeSendFailure& operator=(ProbeSendFailure&& o) { ProbeSendFailure_free(self); self = o.self; memset(&o, 0, sizeof(ProbeSendFailure)); return *this; }
741 LDKProbeSendFailure* operator &() { return &self; }
742 LDKProbeSendFailure* operator ->() { return &self; }
743 const LDKProbeSendFailure* operator &() const { return &self; }
744 const LDKProbeSendFailure* operator ->() const { return &self; }
746 class RecipientOnionFields {
748 LDKRecipientOnionFields self;
750 RecipientOnionFields(const RecipientOnionFields&) = delete;
751 RecipientOnionFields(RecipientOnionFields&& o) : self(o.self) { memset(&o, 0, sizeof(RecipientOnionFields)); }
752 RecipientOnionFields(LDKRecipientOnionFields&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipientOnionFields)); }
753 operator LDKRecipientOnionFields() && { LDKRecipientOnionFields res = self; memset(&self, 0, sizeof(LDKRecipientOnionFields)); return res; }
754 ~RecipientOnionFields() { RecipientOnionFields_free(self); }
755 RecipientOnionFields& operator=(RecipientOnionFields&& o) { RecipientOnionFields_free(self); self = o.self; memset(&o, 0, sizeof(RecipientOnionFields)); return *this; }
756 LDKRecipientOnionFields* operator &() { return &self; }
757 LDKRecipientOnionFields* operator ->() { return &self; }
758 const LDKRecipientOnionFields* operator &() const { return &self; }
759 const LDKRecipientOnionFields* operator ->() const { return &self; }
761 class UnsignedBolt12Invoice {
763 LDKUnsignedBolt12Invoice self;
765 UnsignedBolt12Invoice(const UnsignedBolt12Invoice&) = delete;
766 UnsignedBolt12Invoice(UnsignedBolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedBolt12Invoice)); }
767 UnsignedBolt12Invoice(LDKUnsignedBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedBolt12Invoice)); }
768 operator LDKUnsignedBolt12Invoice() && { LDKUnsignedBolt12Invoice res = self; memset(&self, 0, sizeof(LDKUnsignedBolt12Invoice)); return res; }
769 ~UnsignedBolt12Invoice() { UnsignedBolt12Invoice_free(self); }
770 UnsignedBolt12Invoice& operator=(UnsignedBolt12Invoice&& o) { UnsignedBolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedBolt12Invoice)); return *this; }
771 LDKUnsignedBolt12Invoice* operator &() { return &self; }
772 LDKUnsignedBolt12Invoice* operator ->() { return &self; }
773 const LDKUnsignedBolt12Invoice* operator &() const { return &self; }
774 const LDKUnsignedBolt12Invoice* operator ->() const { return &self; }
776 class Bolt12Invoice {
778 LDKBolt12Invoice self;
780 Bolt12Invoice(const Bolt12Invoice&) = delete;
781 Bolt12Invoice(Bolt12Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12Invoice)); }
782 Bolt12Invoice(LDKBolt12Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12Invoice)); }
783 operator LDKBolt12Invoice() && { LDKBolt12Invoice res = self; memset(&self, 0, sizeof(LDKBolt12Invoice)); return res; }
784 ~Bolt12Invoice() { Bolt12Invoice_free(self); }
785 Bolt12Invoice& operator=(Bolt12Invoice&& o) { Bolt12Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12Invoice)); return *this; }
786 LDKBolt12Invoice* operator &() { return &self; }
787 LDKBolt12Invoice* operator ->() { return &self; }
788 const LDKBolt12Invoice* operator &() const { return &self; }
789 const LDKBolt12Invoice* operator ->() const { return &self; }
791 class BlindedPayInfo {
793 LDKBlindedPayInfo self;
795 BlindedPayInfo(const BlindedPayInfo&) = delete;
796 BlindedPayInfo(BlindedPayInfo&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPayInfo)); }
797 BlindedPayInfo(LDKBlindedPayInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPayInfo)); }
798 operator LDKBlindedPayInfo() && { LDKBlindedPayInfo res = self; memset(&self, 0, sizeof(LDKBlindedPayInfo)); return res; }
799 ~BlindedPayInfo() { BlindedPayInfo_free(self); }
800 BlindedPayInfo& operator=(BlindedPayInfo&& o) { BlindedPayInfo_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPayInfo)); return *this; }
801 LDKBlindedPayInfo* operator &() { return &self; }
802 LDKBlindedPayInfo* operator ->() { return &self; }
803 const LDKBlindedPayInfo* operator &() const { return &self; }
804 const LDKBlindedPayInfo* operator ->() const { return &self; }
806 class DelayedPaymentOutputDescriptor {
808 LDKDelayedPaymentOutputDescriptor self;
810 DelayedPaymentOutputDescriptor(const DelayedPaymentOutputDescriptor&) = delete;
811 DelayedPaymentOutputDescriptor(DelayedPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); }
812 DelayedPaymentOutputDescriptor(LDKDelayedPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); }
813 operator LDKDelayedPaymentOutputDescriptor() && { LDKDelayedPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKDelayedPaymentOutputDescriptor)); return res; }
814 ~DelayedPaymentOutputDescriptor() { DelayedPaymentOutputDescriptor_free(self); }
815 DelayedPaymentOutputDescriptor& operator=(DelayedPaymentOutputDescriptor&& o) { DelayedPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentOutputDescriptor)); return *this; }
816 LDKDelayedPaymentOutputDescriptor* operator &() { return &self; }
817 LDKDelayedPaymentOutputDescriptor* operator ->() { return &self; }
818 const LDKDelayedPaymentOutputDescriptor* operator &() const { return &self; }
819 const LDKDelayedPaymentOutputDescriptor* operator ->() const { return &self; }
821 class StaticPaymentOutputDescriptor {
823 LDKStaticPaymentOutputDescriptor self;
825 StaticPaymentOutputDescriptor(const StaticPaymentOutputDescriptor&) = delete;
826 StaticPaymentOutputDescriptor(StaticPaymentOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); }
827 StaticPaymentOutputDescriptor(LDKStaticPaymentOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); }
828 operator LDKStaticPaymentOutputDescriptor() && { LDKStaticPaymentOutputDescriptor res = self; memset(&self, 0, sizeof(LDKStaticPaymentOutputDescriptor)); return res; }
829 ~StaticPaymentOutputDescriptor() { StaticPaymentOutputDescriptor_free(self); }
830 StaticPaymentOutputDescriptor& operator=(StaticPaymentOutputDescriptor&& o) { StaticPaymentOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(StaticPaymentOutputDescriptor)); return *this; }
831 LDKStaticPaymentOutputDescriptor* operator &() { return &self; }
832 LDKStaticPaymentOutputDescriptor* operator ->() { return &self; }
833 const LDKStaticPaymentOutputDescriptor* operator &() const { return &self; }
834 const LDKStaticPaymentOutputDescriptor* operator ->() const { return &self; }
836 class SpendableOutputDescriptor {
838 LDKSpendableOutputDescriptor self;
840 SpendableOutputDescriptor(const SpendableOutputDescriptor&) = delete;
841 SpendableOutputDescriptor(SpendableOutputDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SpendableOutputDescriptor)); }
842 SpendableOutputDescriptor(LDKSpendableOutputDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpendableOutputDescriptor)); }
843 operator LDKSpendableOutputDescriptor() && { LDKSpendableOutputDescriptor res = self; memset(&self, 0, sizeof(LDKSpendableOutputDescriptor)); return res; }
844 ~SpendableOutputDescriptor() { SpendableOutputDescriptor_free(self); }
845 SpendableOutputDescriptor& operator=(SpendableOutputDescriptor&& o) { SpendableOutputDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SpendableOutputDescriptor)); return *this; }
846 LDKSpendableOutputDescriptor* operator &() { return &self; }
847 LDKSpendableOutputDescriptor* operator ->() { return &self; }
848 const LDKSpendableOutputDescriptor* operator &() const { return &self; }
849 const LDKSpendableOutputDescriptor* operator ->() const { return &self; }
851 class ChannelDerivationParameters {
853 LDKChannelDerivationParameters self;
855 ChannelDerivationParameters(const ChannelDerivationParameters&) = delete;
856 ChannelDerivationParameters(ChannelDerivationParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDerivationParameters)); }
857 ChannelDerivationParameters(LDKChannelDerivationParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDerivationParameters)); }
858 operator LDKChannelDerivationParameters() && { LDKChannelDerivationParameters res = self; memset(&self, 0, sizeof(LDKChannelDerivationParameters)); return res; }
859 ~ChannelDerivationParameters() { ChannelDerivationParameters_free(self); }
860 ChannelDerivationParameters& operator=(ChannelDerivationParameters&& o) { ChannelDerivationParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDerivationParameters)); return *this; }
861 LDKChannelDerivationParameters* operator &() { return &self; }
862 LDKChannelDerivationParameters* operator ->() { return &self; }
863 const LDKChannelDerivationParameters* operator &() const { return &self; }
864 const LDKChannelDerivationParameters* operator ->() const { return &self; }
866 class HTLCDescriptor {
868 LDKHTLCDescriptor self;
870 HTLCDescriptor(const HTLCDescriptor&) = delete;
871 HTLCDescriptor(HTLCDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDescriptor)); }
872 HTLCDescriptor(LDKHTLCDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDescriptor)); }
873 operator LDKHTLCDescriptor() && { LDKHTLCDescriptor res = self; memset(&self, 0, sizeof(LDKHTLCDescriptor)); return res; }
874 ~HTLCDescriptor() { HTLCDescriptor_free(self); }
875 HTLCDescriptor& operator=(HTLCDescriptor&& o) { HTLCDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDescriptor)); return *this; }
876 LDKHTLCDescriptor* operator &() { return &self; }
877 LDKHTLCDescriptor* operator ->() { return &self; }
878 const LDKHTLCDescriptor* operator &() const { return &self; }
879 const LDKHTLCDescriptor* operator ->() const { return &self; }
881 class ChannelSigner {
883 LDKChannelSigner self;
885 ChannelSigner(const ChannelSigner&) = delete;
886 ChannelSigner(ChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelSigner)); }
887 ChannelSigner(LDKChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelSigner)); }
888 operator LDKChannelSigner() && { LDKChannelSigner res = self; memset(&self, 0, sizeof(LDKChannelSigner)); return res; }
889 ~ChannelSigner() { ChannelSigner_free(self); }
890 ChannelSigner& operator=(ChannelSigner&& o) { ChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(ChannelSigner)); return *this; }
891 LDKChannelSigner* operator &() { return &self; }
892 LDKChannelSigner* operator ->() { return &self; }
893 const LDKChannelSigner* operator &() const { return &self; }
894 const LDKChannelSigner* operator ->() const { return &self; }
896 * Gets the per-commitment point for a specific commitment number
898 * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
900 inline LDKPublicKey get_per_commitment_point(uint64_t idx);
902 * Gets the commitment secret for a specific commitment number as part of the revocation process
904 * An external signer implementation should error here if the commitment was already signed
905 * and should refuse to sign it in the future.
907 * May be called more than once for the same index.
909 * Note that the commitment number starts at `(1 << 48) - 1` and counts backwards.
911 inline LDKThirtyTwoBytes release_commitment_secret(uint64_t idx);
913 * Validate the counterparty's signatures on the holder commitment transaction and HTLCs.
915 * This is required in order for the signer to make sure that releasing a commitment
916 * secret won't leave us without a broadcastable holder transaction.
917 * Policy checks should be implemented in this function, including checking the amount
918 * sent to us and checking the HTLCs.
920 * The preimages of outbound HTLCs that were fulfilled since the last commitment are provided.
921 * A validating signer should ensure that an HTLC output is removed only when the matching
922 * preimage is provided, or when the value to holder is restored.
924 * Note that all the relevant preimages will be provided, but there may also be additional
925 * irrelevant or duplicate preimages.
927 inline LDK::CResult_NoneNoneZ validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
929 * Validate the counterparty's revocation.
931 * This is required in order for the signer to make sure that the state has moved
932 * forward and it is safe to sign the next counterparty commitment.
934 inline LDK::CResult_NoneNoneZ validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]);
936 * Returns an arbitrary identifier describing the set of keys which are provided back to you in
937 * some [`SpendableOutputDescriptor`] types. This should be sufficient to identify this
938 * [`EcdsaChannelSigner`] object uniquely and lookup or re-derive its keys.
940 inline LDKThirtyTwoBytes channel_keys_id();
942 * Set the counterparty static channel data, including basepoints,
943 * `counterparty_selected`/`holder_selected_contest_delay` and funding outpoint.
945 * This data is static, and will never change for a channel once set. For a given [`ChannelSigner`]
946 * instance, LDK will call this method exactly once - either immediately after construction
947 * (not including if done via [`SignerProvider::read_chan_signer`]) or when the funding
948 * information has been generated.
950 * channel_parameters.is_populated() MUST be true.
952 inline void provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters);
958 Recipient(const Recipient&) = delete;
959 Recipient(Recipient&& o) : self(o.self) { memset(&o, 0, sizeof(Recipient)); }
960 Recipient(LDKRecipient&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecipient)); }
961 operator LDKRecipient() && { LDKRecipient res = self; memset(&self, 0, sizeof(LDKRecipient)); return res; }
962 Recipient& operator=(Recipient&& o) { self = o.self; memset(&o, 0, sizeof(Recipient)); return *this; }
963 LDKRecipient* operator &() { return &self; }
964 LDKRecipient* operator ->() { return &self; }
965 const LDKRecipient* operator &() const { return &self; }
966 const LDKRecipient* operator ->() const { return &self; }
968 class EntropySource {
970 LDKEntropySource self;
972 EntropySource(const EntropySource&) = delete;
973 EntropySource(EntropySource&& o) : self(o.self) { memset(&o, 0, sizeof(EntropySource)); }
974 EntropySource(LDKEntropySource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEntropySource)); }
975 operator LDKEntropySource() && { LDKEntropySource res = self; memset(&self, 0, sizeof(LDKEntropySource)); return res; }
976 ~EntropySource() { EntropySource_free(self); }
977 EntropySource& operator=(EntropySource&& o) { EntropySource_free(self); self = o.self; memset(&o, 0, sizeof(EntropySource)); return *this; }
978 LDKEntropySource* operator &() { return &self; }
979 LDKEntropySource* operator ->() { return &self; }
980 const LDKEntropySource* operator &() const { return &self; }
981 const LDKEntropySource* operator ->() const { return &self; }
983 * Gets a unique, cryptographically-secure, random 32-byte value. This method must return a
984 * different value each time it is called.
986 inline LDKThirtyTwoBytes get_secure_random_bytes();
992 NodeSigner(const NodeSigner&) = delete;
993 NodeSigner(NodeSigner&& o) : self(o.self) { memset(&o, 0, sizeof(NodeSigner)); }
994 NodeSigner(LDKNodeSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeSigner)); }
995 operator LDKNodeSigner() && { LDKNodeSigner res = self; memset(&self, 0, sizeof(LDKNodeSigner)); return res; }
996 ~NodeSigner() { NodeSigner_free(self); }
997 NodeSigner& operator=(NodeSigner&& o) { NodeSigner_free(self); self = o.self; memset(&o, 0, sizeof(NodeSigner)); return *this; }
998 LDKNodeSigner* operator &() { return &self; }
999 LDKNodeSigner* operator ->() { return &self; }
1000 const LDKNodeSigner* operator &() const { return &self; }
1001 const LDKNodeSigner* operator ->() const { return &self; }
1003 * Get secret key material as bytes for use in encrypting and decrypting inbound payment data.
1005 * If the implementor of this trait supports [phantom node payments], then every node that is
1006 * intended to be included in the phantom invoice route hints must return the same value from
1009 * This method must return the same value each time it is called.
1011 * [phantom node payments]: PhantomKeysManager
1013 inline LDKThirtyTwoBytes get_inbound_payment_key_material();
1015 * Get node id based on the provided [`Recipient`].
1017 * This method must return the same value each time it is called with a given [`Recipient`]
1020 * Errors if the [`Recipient`] variant is not supported by the implementation.
1022 inline LDK::CResult_PublicKeyNoneZ get_node_id(enum LDKRecipient recipient);
1024 * Gets the ECDH shared secret of our node secret and `other_key`, multiplying by `tweak` if
1025 * one is provided. Note that this tweak can be applied to `other_key` instead of our node
1026 * secret, though this is less efficient.
1028 * Note that if this fails while attempting to forward an HTLC, LDK will panic. The error
1029 * should be resolved to allow LDK to resume forwarding HTLCs.
1031 * Errors if the [`Recipient`] variant is not supported by the implementation.
1033 inline LDK::CResult_ThirtyTwoBytesNoneZ ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak);
1037 * By parameterizing by the raw invoice bytes instead of the hash, we allow implementors of
1038 * this trait to parse the invoice and make sure they're signing what they expect, rather than
1039 * blindly signing the hash.
1041 * The `hrp_bytes` are ASCII bytes, while the `invoice_data` is base32.
1043 * The secret key used to sign the invoice is dependent on the [`Recipient`].
1045 * Errors if the [`Recipient`] variant is not supported by the implementation.
1047 inline LDK::CResult_RecoverableSignatureNoneZ sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient);
1049 * Signs the [`TaggedHash`] of a BOLT 12 invoice request.
1051 * May be called by a function passed to [`UnsignedInvoiceRequest::sign`] where
1052 * `invoice_request` is the callee.
1054 * Implementors may check that the `invoice_request` is expected rather than blindly signing
1055 * the tagged hash. An `Ok` result should sign `invoice_request.tagged_hash().as_digest()` with
1056 * the node's signing key or an ephemeral key to preserve privacy, whichever is associated with
1057 * [`UnsignedInvoiceRequest::payer_id`].
1059 * [`TaggedHash`]: crate::offers::merkle::TaggedHash
1061 inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request);
1063 * Signs the [`TaggedHash`] of a BOLT 12 invoice.
1065 * May be called by a function passed to [`UnsignedBolt12Invoice::sign`] where `invoice` is the
1068 * Implementors may check that the `invoice` is expected rather than blindly signing the tagged
1069 * hash. An `Ok` result should sign `invoice.tagged_hash().as_digest()` with the node's signing
1070 * key or an ephemeral key to preserve privacy, whichever is associated with
1071 * [`UnsignedBolt12Invoice::signing_pubkey`].
1073 * [`TaggedHash`]: crate::offers::merkle::TaggedHash
1075 inline LDK::CResult_SchnorrSignatureNoneZ sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice);
1077 * Sign a gossip message.
1079 * Note that if this fails, LDK may panic and the message will not be broadcast to the network
1080 * or a possible channel counterparty. If LDK panics, the error should be resolved to allow the
1081 * message to be broadcast, as otherwise it may prevent one from receiving funds over the
1082 * corresponding channel.
1084 inline LDK::CResult_ECDSASignatureNoneZ sign_gossip_message(struct LDKUnsignedGossipMessage msg);
1086 class SignerProvider {
1088 LDKSignerProvider self;
1090 SignerProvider(const SignerProvider&) = delete;
1091 SignerProvider(SignerProvider&& o) : self(o.self) { memset(&o, 0, sizeof(SignerProvider)); }
1092 SignerProvider(LDKSignerProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignerProvider)); }
1093 operator LDKSignerProvider() && { LDKSignerProvider res = self; memset(&self, 0, sizeof(LDKSignerProvider)); return res; }
1094 ~SignerProvider() { SignerProvider_free(self); }
1095 SignerProvider& operator=(SignerProvider&& o) { SignerProvider_free(self); self = o.self; memset(&o, 0, sizeof(SignerProvider)); return *this; }
1096 LDKSignerProvider* operator &() { return &self; }
1097 LDKSignerProvider* operator ->() { return &self; }
1098 const LDKSignerProvider* operator &() const { return &self; }
1099 const LDKSignerProvider* operator ->() const { return &self; }
1101 * Generates a unique `channel_keys_id` that can be used to obtain a [`Self::EcdsaSigner`] through
1102 * [`SignerProvider::derive_channel_signer`]. The `user_channel_id` is provided to allow
1103 * implementations of [`SignerProvider`] to maintain a mapping between itself and the generated
1104 * `channel_keys_id`.
1106 * This method must return a different value each time it is called.
1108 inline LDKThirtyTwoBytes generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id);
1110 * Derives the private key material backing a `Signer`.
1112 * To derive a new `Signer`, a fresh `channel_keys_id` should be obtained through
1113 * [`SignerProvider::generate_channel_keys_id`]. Otherwise, an existing `Signer` can be
1114 * re-derived from its `channel_keys_id`, which can be obtained through its trait method
1115 * [`ChannelSigner::channel_keys_id`].
1117 inline LDK::WriteableEcdsaChannelSigner derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id);
1119 * Reads a [`Signer`] for this [`SignerProvider`] from the given input stream.
1120 * This is only called during deserialization of other objects which contain
1121 * [`WriteableEcdsaChannelSigner`]-implementing objects (i.e., [`ChannelMonitor`]s and [`ChannelManager`]s).
1122 * The bytes are exactly those which `<Self::Signer as Writeable>::write()` writes, and
1123 * contain no versioning scheme. You may wish to include your own version prefix and ensure
1124 * you've read all of the provided bytes to ensure no corruption occurred.
1126 * This method is slowly being phased out -- it will only be called when reading objects
1127 * written by LDK versions prior to 0.0.113.
1129 * [`Signer`]: Self::EcdsaSigner
1130 * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
1131 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1133 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer(struct LDKu8slice reader);
1135 * Get a script pubkey which we send funds to when claiming on-chain contestable outputs.
1137 * If this function returns an error, this will result in a channel failing to open.
1139 * This method should return a different value each time it is called, to avoid linking
1140 * on-chain funds across channels as controlled to the same user. `channel_keys_id` may be
1141 * used to derive a unique value for each channel.
1143 inline LDK::CResult_CVec_u8ZNoneZ get_destination_script(struct LDKThirtyTwoBytes channel_keys_id);
1145 * Get a script pubkey which we will send funds to when closing a channel.
1147 * If this function returns an error, this will result in a channel failing to open or close.
1148 * In the event of a failure when the counterparty is initiating a close, this can result in a
1149 * channel force close.
1151 * This method should return a different value each time it is called, to avoid linking
1152 * on-chain funds across channels as controlled to the same user.
1154 inline LDK::CResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey();
1156 class InMemorySigner {
1158 LDKInMemorySigner self;
1160 InMemorySigner(const InMemorySigner&) = delete;
1161 InMemorySigner(InMemorySigner&& o) : self(o.self) { memset(&o, 0, sizeof(InMemorySigner)); }
1162 InMemorySigner(LDKInMemorySigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInMemorySigner)); }
1163 operator LDKInMemorySigner() && { LDKInMemorySigner res = self; memset(&self, 0, sizeof(LDKInMemorySigner)); return res; }
1164 ~InMemorySigner() { InMemorySigner_free(self); }
1165 InMemorySigner& operator=(InMemorySigner&& o) { InMemorySigner_free(self); self = o.self; memset(&o, 0, sizeof(InMemorySigner)); return *this; }
1166 LDKInMemorySigner* operator &() { return &self; }
1167 LDKInMemorySigner* operator ->() { return &self; }
1168 const LDKInMemorySigner* operator &() const { return &self; }
1169 const LDKInMemorySigner* operator ->() const { return &self; }
1173 LDKKeysManager self;
1175 KeysManager(const KeysManager&) = delete;
1176 KeysManager(KeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(KeysManager)); }
1177 KeysManager(LDKKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKeysManager)); }
1178 operator LDKKeysManager() && { LDKKeysManager res = self; memset(&self, 0, sizeof(LDKKeysManager)); return res; }
1179 ~KeysManager() { KeysManager_free(self); }
1180 KeysManager& operator=(KeysManager&& o) { KeysManager_free(self); self = o.self; memset(&o, 0, sizeof(KeysManager)); return *this; }
1181 LDKKeysManager* operator &() { return &self; }
1182 LDKKeysManager* operator ->() { return &self; }
1183 const LDKKeysManager* operator &() const { return &self; }
1184 const LDKKeysManager* operator ->() const { return &self; }
1186 class PhantomKeysManager {
1188 LDKPhantomKeysManager self;
1190 PhantomKeysManager(const PhantomKeysManager&) = delete;
1191 PhantomKeysManager(PhantomKeysManager&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomKeysManager)); }
1192 PhantomKeysManager(LDKPhantomKeysManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomKeysManager)); }
1193 operator LDKPhantomKeysManager() && { LDKPhantomKeysManager res = self; memset(&self, 0, sizeof(LDKPhantomKeysManager)); return res; }
1194 ~PhantomKeysManager() { PhantomKeysManager_free(self); }
1195 PhantomKeysManager& operator=(PhantomKeysManager&& o) { PhantomKeysManager_free(self); self = o.self; memset(&o, 0, sizeof(PhantomKeysManager)); return *this; }
1196 LDKPhantomKeysManager* operator &() { return &self; }
1197 LDKPhantomKeysManager* operator ->() { return &self; }
1198 const LDKPhantomKeysManager* operator &() const { return &self; }
1199 const LDKPhantomKeysManager* operator ->() const { return &self; }
1201 class BackgroundProcessor {
1203 LDKBackgroundProcessor self;
1205 BackgroundProcessor(const BackgroundProcessor&) = delete;
1206 BackgroundProcessor(BackgroundProcessor&& o) : self(o.self) { memset(&o, 0, sizeof(BackgroundProcessor)); }
1207 BackgroundProcessor(LDKBackgroundProcessor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBackgroundProcessor)); }
1208 operator LDKBackgroundProcessor() && { LDKBackgroundProcessor res = self; memset(&self, 0, sizeof(LDKBackgroundProcessor)); return res; }
1209 ~BackgroundProcessor() { BackgroundProcessor_free(self); }
1210 BackgroundProcessor& operator=(BackgroundProcessor&& o) { BackgroundProcessor_free(self); self = o.self; memset(&o, 0, sizeof(BackgroundProcessor)); return *this; }
1211 LDKBackgroundProcessor* operator &() { return &self; }
1212 LDKBackgroundProcessor* operator ->() { return &self; }
1213 const LDKBackgroundProcessor* operator &() const { return &self; }
1214 const LDKBackgroundProcessor* operator ->() const { return &self; }
1220 GossipSync(const GossipSync&) = delete;
1221 GossipSync(GossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(GossipSync)); }
1222 GossipSync(LDKGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipSync)); }
1223 operator LDKGossipSync() && { LDKGossipSync res = self; memset(&self, 0, sizeof(LDKGossipSync)); return res; }
1224 ~GossipSync() { GossipSync_free(self); }
1225 GossipSync& operator=(GossipSync&& o) { GossipSync_free(self); self = o.self; memset(&o, 0, sizeof(GossipSync)); return *this; }
1226 LDKGossipSync* operator &() { return &self; }
1227 LDKGossipSync* operator ->() { return &self; }
1228 const LDKGossipSync* operator &() const { return &self; }
1229 const LDKGossipSync* operator ->() const { return &self; }
1231 class DefaultRouter {
1233 LDKDefaultRouter self;
1235 DefaultRouter(const DefaultRouter&) = delete;
1236 DefaultRouter(DefaultRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultRouter)); }
1237 DefaultRouter(LDKDefaultRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultRouter)); }
1238 operator LDKDefaultRouter() && { LDKDefaultRouter res = self; memset(&self, 0, sizeof(LDKDefaultRouter)); return res; }
1239 ~DefaultRouter() { DefaultRouter_free(self); }
1240 DefaultRouter& operator=(DefaultRouter&& o) { DefaultRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultRouter)); return *this; }
1241 LDKDefaultRouter* operator &() { return &self; }
1242 LDKDefaultRouter* operator ->() { return &self; }
1243 const LDKDefaultRouter* operator &() const { return &self; }
1244 const LDKDefaultRouter* operator ->() const { return &self; }
1250 Router(const Router&) = delete;
1251 Router(Router&& o) : self(o.self) { memset(&o, 0, sizeof(Router)); }
1252 Router(LDKRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouter)); }
1253 operator LDKRouter() && { LDKRouter res = self; memset(&self, 0, sizeof(LDKRouter)); return res; }
1254 ~Router() { Router_free(self); }
1255 Router& operator=(Router&& o) { Router_free(self); self = o.self; memset(&o, 0, sizeof(Router)); return *this; }
1256 LDKRouter* operator &() { return &self; }
1257 LDKRouter* operator ->() { return &self; }
1258 const LDKRouter* operator &() const { return &self; }
1259 const LDKRouter* operator ->() const { return &self; }
1261 * Finds a [`Route`] for a payment between the given `payer` and a payee.
1263 * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1264 * and [`RouteParameters::final_value_msat`], respectively.
1266 * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1268 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);
1270 * Finds a [`Route`] for a payment between the given `payer` and a payee.
1272 * The `payee` and the payment's value are given in [`RouteParameters::payment_params`]
1273 * and [`RouteParameters::final_value_msat`], respectively.
1275 * Includes a [`PaymentHash`] and a [`PaymentId`] to be able to correlate the request with a specific
1278 * Note that first_hops (or a relevant inner pointer) may be NULL or all-0s to represent None
1280 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);
1282 * Creates [`BlindedPath`]s for payment to the `recipient` node. The channels in `first_hops`
1283 * are assumed to be with the `recipient`'s peers. The payment secret and any constraints are
1286 inline LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats);
1288 class ScorerAccountingForInFlightHtlcs {
1290 LDKScorerAccountingForInFlightHtlcs self;
1292 ScorerAccountingForInFlightHtlcs(const ScorerAccountingForInFlightHtlcs&) = delete;
1293 ScorerAccountingForInFlightHtlcs(ScorerAccountingForInFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); }
1294 ScorerAccountingForInFlightHtlcs(LDKScorerAccountingForInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); }
1295 operator LDKScorerAccountingForInFlightHtlcs() && { LDKScorerAccountingForInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKScorerAccountingForInFlightHtlcs)); return res; }
1296 ~ScorerAccountingForInFlightHtlcs() { ScorerAccountingForInFlightHtlcs_free(self); }
1297 ScorerAccountingForInFlightHtlcs& operator=(ScorerAccountingForInFlightHtlcs&& o) { ScorerAccountingForInFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(ScorerAccountingForInFlightHtlcs)); return *this; }
1298 LDKScorerAccountingForInFlightHtlcs* operator &() { return &self; }
1299 LDKScorerAccountingForInFlightHtlcs* operator ->() { return &self; }
1300 const LDKScorerAccountingForInFlightHtlcs* operator &() const { return &self; }
1301 const LDKScorerAccountingForInFlightHtlcs* operator ->() const { return &self; }
1303 class InFlightHtlcs {
1305 LDKInFlightHtlcs self;
1307 InFlightHtlcs(const InFlightHtlcs&) = delete;
1308 InFlightHtlcs(InFlightHtlcs&& o) : self(o.self) { memset(&o, 0, sizeof(InFlightHtlcs)); }
1309 InFlightHtlcs(LDKInFlightHtlcs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInFlightHtlcs)); }
1310 operator LDKInFlightHtlcs() && { LDKInFlightHtlcs res = self; memset(&self, 0, sizeof(LDKInFlightHtlcs)); return res; }
1311 ~InFlightHtlcs() { InFlightHtlcs_free(self); }
1312 InFlightHtlcs& operator=(InFlightHtlcs&& o) { InFlightHtlcs_free(self); self = o.self; memset(&o, 0, sizeof(InFlightHtlcs)); return *this; }
1313 LDKInFlightHtlcs* operator &() { return &self; }
1314 LDKInFlightHtlcs* operator ->() { return &self; }
1315 const LDKInFlightHtlcs* operator &() const { return &self; }
1316 const LDKInFlightHtlcs* operator ->() const { return &self; }
1322 RouteHop(const RouteHop&) = delete;
1323 RouteHop(RouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHop)); }
1324 RouteHop(LDKRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHop)); }
1325 operator LDKRouteHop() && { LDKRouteHop res = self; memset(&self, 0, sizeof(LDKRouteHop)); return res; }
1326 ~RouteHop() { RouteHop_free(self); }
1327 RouteHop& operator=(RouteHop&& o) { RouteHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHop)); return *this; }
1328 LDKRouteHop* operator &() { return &self; }
1329 LDKRouteHop* operator ->() { return &self; }
1330 const LDKRouteHop* operator &() const { return &self; }
1331 const LDKRouteHop* operator ->() const { return &self; }
1335 LDKBlindedTail self;
1337 BlindedTail(const BlindedTail&) = delete;
1338 BlindedTail(BlindedTail&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedTail)); }
1339 BlindedTail(LDKBlindedTail&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedTail)); }
1340 operator LDKBlindedTail() && { LDKBlindedTail res = self; memset(&self, 0, sizeof(LDKBlindedTail)); return res; }
1341 ~BlindedTail() { BlindedTail_free(self); }
1342 BlindedTail& operator=(BlindedTail&& o) { BlindedTail_free(self); self = o.self; memset(&o, 0, sizeof(BlindedTail)); return *this; }
1343 LDKBlindedTail* operator &() { return &self; }
1344 LDKBlindedTail* operator ->() { return &self; }
1345 const LDKBlindedTail* operator &() const { return &self; }
1346 const LDKBlindedTail* operator ->() const { return &self; }
1352 Path(const Path&) = delete;
1353 Path(Path&& o) : self(o.self) { memset(&o, 0, sizeof(Path)); }
1354 Path(LDKPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPath)); }
1355 operator LDKPath() && { LDKPath res = self; memset(&self, 0, sizeof(LDKPath)); return res; }
1356 ~Path() { Path_free(self); }
1357 Path& operator=(Path&& o) { Path_free(self); self = o.self; memset(&o, 0, sizeof(Path)); return *this; }
1358 LDKPath* operator &() { return &self; }
1359 LDKPath* operator ->() { return &self; }
1360 const LDKPath* operator &() const { return &self; }
1361 const LDKPath* operator ->() const { return &self; }
1367 Route(const Route&) = delete;
1368 Route(Route&& o) : self(o.self) { memset(&o, 0, sizeof(Route)); }
1369 Route(LDKRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoute)); }
1370 operator LDKRoute() && { LDKRoute res = self; memset(&self, 0, sizeof(LDKRoute)); return res; }
1371 ~Route() { Route_free(self); }
1372 Route& operator=(Route&& o) { Route_free(self); self = o.self; memset(&o, 0, sizeof(Route)); return *this; }
1373 LDKRoute* operator &() { return &self; }
1374 LDKRoute* operator ->() { return &self; }
1375 const LDKRoute* operator &() const { return &self; }
1376 const LDKRoute* operator ->() const { return &self; }
1378 class RouteParameters {
1380 LDKRouteParameters self;
1382 RouteParameters(const RouteParameters&) = delete;
1383 RouteParameters(RouteParameters&& o) : self(o.self) { memset(&o, 0, sizeof(RouteParameters)); }
1384 RouteParameters(LDKRouteParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteParameters)); }
1385 operator LDKRouteParameters() && { LDKRouteParameters res = self; memset(&self, 0, sizeof(LDKRouteParameters)); return res; }
1386 ~RouteParameters() { RouteParameters_free(self); }
1387 RouteParameters& operator=(RouteParameters&& o) { RouteParameters_free(self); self = o.self; memset(&o, 0, sizeof(RouteParameters)); return *this; }
1388 LDKRouteParameters* operator &() { return &self; }
1389 LDKRouteParameters* operator ->() { return &self; }
1390 const LDKRouteParameters* operator &() const { return &self; }
1391 const LDKRouteParameters* operator ->() const { return &self; }
1393 class PaymentParameters {
1395 LDKPaymentParameters self;
1397 PaymentParameters(const PaymentParameters&) = delete;
1398 PaymentParameters(PaymentParameters&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentParameters)); }
1399 PaymentParameters(LDKPaymentParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentParameters)); }
1400 operator LDKPaymentParameters() && { LDKPaymentParameters res = self; memset(&self, 0, sizeof(LDKPaymentParameters)); return res; }
1401 ~PaymentParameters() { PaymentParameters_free(self); }
1402 PaymentParameters& operator=(PaymentParameters&& o) { PaymentParameters_free(self); self = o.self; memset(&o, 0, sizeof(PaymentParameters)); return *this; }
1403 LDKPaymentParameters* operator &() { return &self; }
1404 LDKPaymentParameters* operator ->() { return &self; }
1405 const LDKPaymentParameters* operator &() const { return &self; }
1406 const LDKPaymentParameters* operator ->() const { return &self; }
1412 Payee(const Payee&) = delete;
1413 Payee(Payee&& o) : self(o.self) { memset(&o, 0, sizeof(Payee)); }
1414 Payee(LDKPayee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayee)); }
1415 operator LDKPayee() && { LDKPayee res = self; memset(&self, 0, sizeof(LDKPayee)); return res; }
1416 ~Payee() { Payee_free(self); }
1417 Payee& operator=(Payee&& o) { Payee_free(self); self = o.self; memset(&o, 0, sizeof(Payee)); return *this; }
1418 LDKPayee* operator &() { return &self; }
1419 LDKPayee* operator ->() { return &self; }
1420 const LDKPayee* operator &() const { return &self; }
1421 const LDKPayee* operator ->() const { return &self; }
1427 RouteHint(const RouteHint&) = delete;
1428 RouteHint(RouteHint&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHint)); }
1429 RouteHint(LDKRouteHint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHint)); }
1430 operator LDKRouteHint() && { LDKRouteHint res = self; memset(&self, 0, sizeof(LDKRouteHint)); return res; }
1431 ~RouteHint() { RouteHint_free(self); }
1432 RouteHint& operator=(RouteHint&& o) { RouteHint_free(self); self = o.self; memset(&o, 0, sizeof(RouteHint)); return *this; }
1433 LDKRouteHint* operator &() { return &self; }
1434 LDKRouteHint* operator ->() { return &self; }
1435 const LDKRouteHint* operator &() const { return &self; }
1436 const LDKRouteHint* operator ->() const { return &self; }
1438 class RouteHintHop {
1440 LDKRouteHintHop self;
1442 RouteHintHop(const RouteHintHop&) = delete;
1443 RouteHintHop(RouteHintHop&& o) : self(o.self) { memset(&o, 0, sizeof(RouteHintHop)); }
1444 RouteHintHop(LDKRouteHintHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRouteHintHop)); }
1445 operator LDKRouteHintHop() && { LDKRouteHintHop res = self; memset(&self, 0, sizeof(LDKRouteHintHop)); return res; }
1446 ~RouteHintHop() { RouteHintHop_free(self); }
1447 RouteHintHop& operator=(RouteHintHop&& o) { RouteHintHop_free(self); self = o.self; memset(&o, 0, sizeof(RouteHintHop)); return *this; }
1448 LDKRouteHintHop* operator &() { return &self; }
1449 LDKRouteHintHop* operator ->() { return &self; }
1450 const LDKRouteHintHop* operator &() const { return &self; }
1451 const LDKRouteHintHop* operator ->() const { return &self; }
1453 class FirstHopCandidate {
1455 LDKFirstHopCandidate self;
1457 FirstHopCandidate(const FirstHopCandidate&) = delete;
1458 FirstHopCandidate(FirstHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(FirstHopCandidate)); }
1459 FirstHopCandidate(LDKFirstHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFirstHopCandidate)); }
1460 operator LDKFirstHopCandidate() && { LDKFirstHopCandidate res = self; memset(&self, 0, sizeof(LDKFirstHopCandidate)); return res; }
1461 ~FirstHopCandidate() { FirstHopCandidate_free(self); }
1462 FirstHopCandidate& operator=(FirstHopCandidate&& o) { FirstHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(FirstHopCandidate)); return *this; }
1463 LDKFirstHopCandidate* operator &() { return &self; }
1464 LDKFirstHopCandidate* operator ->() { return &self; }
1465 const LDKFirstHopCandidate* operator &() const { return &self; }
1466 const LDKFirstHopCandidate* operator ->() const { return &self; }
1468 class PublicHopCandidate {
1470 LDKPublicHopCandidate self;
1472 PublicHopCandidate(const PublicHopCandidate&) = delete;
1473 PublicHopCandidate(PublicHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PublicHopCandidate)); }
1474 PublicHopCandidate(LDKPublicHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPublicHopCandidate)); }
1475 operator LDKPublicHopCandidate() && { LDKPublicHopCandidate res = self; memset(&self, 0, sizeof(LDKPublicHopCandidate)); return res; }
1476 ~PublicHopCandidate() { PublicHopCandidate_free(self); }
1477 PublicHopCandidate& operator=(PublicHopCandidate&& o) { PublicHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PublicHopCandidate)); return *this; }
1478 LDKPublicHopCandidate* operator &() { return &self; }
1479 LDKPublicHopCandidate* operator ->() { return &self; }
1480 const LDKPublicHopCandidate* operator &() const { return &self; }
1481 const LDKPublicHopCandidate* operator ->() const { return &self; }
1483 class PrivateHopCandidate {
1485 LDKPrivateHopCandidate self;
1487 PrivateHopCandidate(const PrivateHopCandidate&) = delete;
1488 PrivateHopCandidate(PrivateHopCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateHopCandidate)); }
1489 PrivateHopCandidate(LDKPrivateHopCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateHopCandidate)); }
1490 operator LDKPrivateHopCandidate() && { LDKPrivateHopCandidate res = self; memset(&self, 0, sizeof(LDKPrivateHopCandidate)); return res; }
1491 ~PrivateHopCandidate() { PrivateHopCandidate_free(self); }
1492 PrivateHopCandidate& operator=(PrivateHopCandidate&& o) { PrivateHopCandidate_free(self); self = o.self; memset(&o, 0, sizeof(PrivateHopCandidate)); return *this; }
1493 LDKPrivateHopCandidate* operator &() { return &self; }
1494 LDKPrivateHopCandidate* operator ->() { return &self; }
1495 const LDKPrivateHopCandidate* operator &() const { return &self; }
1496 const LDKPrivateHopCandidate* operator ->() const { return &self; }
1498 class BlindedPathCandidate {
1500 LDKBlindedPathCandidate self;
1502 BlindedPathCandidate(const BlindedPathCandidate&) = delete;
1503 BlindedPathCandidate(BlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPathCandidate)); }
1504 BlindedPathCandidate(LDKBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPathCandidate)); }
1505 operator LDKBlindedPathCandidate() && { LDKBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKBlindedPathCandidate)); return res; }
1506 ~BlindedPathCandidate() { BlindedPathCandidate_free(self); }
1507 BlindedPathCandidate& operator=(BlindedPathCandidate&& o) { BlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPathCandidate)); return *this; }
1508 LDKBlindedPathCandidate* operator &() { return &self; }
1509 LDKBlindedPathCandidate* operator ->() { return &self; }
1510 const LDKBlindedPathCandidate* operator &() const { return &self; }
1511 const LDKBlindedPathCandidate* operator ->() const { return &self; }
1513 class OneHopBlindedPathCandidate {
1515 LDKOneHopBlindedPathCandidate self;
1517 OneHopBlindedPathCandidate(const OneHopBlindedPathCandidate&) = delete;
1518 OneHopBlindedPathCandidate(OneHopBlindedPathCandidate&& o) : self(o.self) { memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); }
1519 OneHopBlindedPathCandidate(LDKOneHopBlindedPathCandidate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOneHopBlindedPathCandidate)); }
1520 operator LDKOneHopBlindedPathCandidate() && { LDKOneHopBlindedPathCandidate res = self; memset(&self, 0, sizeof(LDKOneHopBlindedPathCandidate)); return res; }
1521 ~OneHopBlindedPathCandidate() { OneHopBlindedPathCandidate_free(self); }
1522 OneHopBlindedPathCandidate& operator=(OneHopBlindedPathCandidate&& o) { OneHopBlindedPathCandidate_free(self); self = o.self; memset(&o, 0, sizeof(OneHopBlindedPathCandidate)); return *this; }
1523 LDKOneHopBlindedPathCandidate* operator &() { return &self; }
1524 LDKOneHopBlindedPathCandidate* operator ->() { return &self; }
1525 const LDKOneHopBlindedPathCandidate* operator &() const { return &self; }
1526 const LDKOneHopBlindedPathCandidate* operator ->() const { return &self; }
1528 class CandidateRouteHop {
1530 LDKCandidateRouteHop self;
1532 CandidateRouteHop(const CandidateRouteHop&) = delete;
1533 CandidateRouteHop(CandidateRouteHop&& o) : self(o.self) { memset(&o, 0, sizeof(CandidateRouteHop)); }
1534 CandidateRouteHop(LDKCandidateRouteHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCandidateRouteHop)); }
1535 operator LDKCandidateRouteHop() && { LDKCandidateRouteHop res = self; memset(&self, 0, sizeof(LDKCandidateRouteHop)); return res; }
1536 ~CandidateRouteHop() { CandidateRouteHop_free(self); }
1537 CandidateRouteHop& operator=(CandidateRouteHop&& o) { CandidateRouteHop_free(self); self = o.self; memset(&o, 0, sizeof(CandidateRouteHop)); return *this; }
1538 LDKCandidateRouteHop* operator &() { return &self; }
1539 LDKCandidateRouteHop* operator ->() { return &self; }
1540 const LDKCandidateRouteHop* operator &() const { return &self; }
1541 const LDKCandidateRouteHop* operator ->() const { return &self; }
1545 LDKScoreLookUp self;
1547 ScoreLookUp(const ScoreLookUp&) = delete;
1548 ScoreLookUp(ScoreLookUp&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreLookUp)); }
1549 ScoreLookUp(LDKScoreLookUp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreLookUp)); }
1550 operator LDKScoreLookUp() && { LDKScoreLookUp res = self; memset(&self, 0, sizeof(LDKScoreLookUp)); return res; }
1551 ~ScoreLookUp() { ScoreLookUp_free(self); }
1552 ScoreLookUp& operator=(ScoreLookUp&& o) { ScoreLookUp_free(self); self = o.self; memset(&o, 0, sizeof(ScoreLookUp)); return *this; }
1553 LDKScoreLookUp* operator &() { return &self; }
1554 LDKScoreLookUp* operator ->() { return &self; }
1555 const LDKScoreLookUp* operator &() const { return &self; }
1556 const LDKScoreLookUp* operator ->() const { return &self; }
1558 * Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
1559 * given channel in the direction from `source` to `target`.
1561 * The channel's capacity (less any other MPP parts that are also being considered for use in
1562 * the same payment) is given by `capacity_msat`. It may be determined from various sources
1563 * such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near
1564 * [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
1565 * Thus, implementations should be overflow-safe.
1567 inline uint64_t channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params);
1571 LDKScoreUpdate self;
1573 ScoreUpdate(const ScoreUpdate&) = delete;
1574 ScoreUpdate(ScoreUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ScoreUpdate)); }
1575 ScoreUpdate(LDKScoreUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScoreUpdate)); }
1576 operator LDKScoreUpdate() && { LDKScoreUpdate res = self; memset(&self, 0, sizeof(LDKScoreUpdate)); return res; }
1577 ~ScoreUpdate() { ScoreUpdate_free(self); }
1578 ScoreUpdate& operator=(ScoreUpdate&& o) { ScoreUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ScoreUpdate)); return *this; }
1579 LDKScoreUpdate* operator &() { return &self; }
1580 LDKScoreUpdate* operator ->() { return &self; }
1581 const LDKScoreUpdate* operator &() const { return &self; }
1582 const LDKScoreUpdate* operator ->() const { return &self; }
1584 * Handles updating channel penalties after failing to route through a channel.
1586 inline void payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
1588 * Handles updating channel penalties after successfully routing along a path.
1590 inline void payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
1592 * Handles updating channel penalties after a probe over the given path failed.
1594 inline void probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch);
1596 * Handles updating channel penalties after a probe over the given path succeeded.
1598 inline void probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch);
1600 * Scorers may wish to reduce their certainty of channel liquidity information over time.
1601 * Thus, this method is provided to allow scorers to observe the passage of time - the holder
1602 * of this object should call this method regularly (generally via the
1603 * `lightning-background-processor` crate).
1605 inline void time_passed(uint64_t duration_since_epoch);
1611 Score(const Score&) = delete;
1612 Score(Score&& o) : self(o.self) { memset(&o, 0, sizeof(Score)); }
1613 Score(LDKScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKScore)); }
1614 operator LDKScore() && { LDKScore res = self; memset(&self, 0, sizeof(LDKScore)); return res; }
1615 ~Score() { Score_free(self); }
1616 Score& operator=(Score&& o) { Score_free(self); self = o.self; memset(&o, 0, sizeof(Score)); return *this; }
1617 LDKScore* operator &() { return &self; }
1618 LDKScore* operator ->() { return &self; }
1619 const LDKScore* operator &() const { return &self; }
1620 const LDKScore* operator ->() const { return &self; }
1622 class LockableScore {
1624 LDKLockableScore self;
1626 LockableScore(const LockableScore&) = delete;
1627 LockableScore(LockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(LockableScore)); }
1628 LockableScore(LDKLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockableScore)); }
1629 operator LDKLockableScore() && { LDKLockableScore res = self; memset(&self, 0, sizeof(LDKLockableScore)); return res; }
1630 ~LockableScore() { LockableScore_free(self); }
1631 LockableScore& operator=(LockableScore&& o) { LockableScore_free(self); self = o.self; memset(&o, 0, sizeof(LockableScore)); return *this; }
1632 LDKLockableScore* operator &() { return &self; }
1633 LDKLockableScore* operator ->() { return &self; }
1634 const LDKLockableScore* operator &() const { return &self; }
1635 const LDKLockableScore* operator ->() const { return &self; }
1637 * Returns read locked scorer.
1639 inline LDK::ScoreLookUp read_lock();
1641 * Returns write locked scorer.
1643 inline LDK::ScoreUpdate write_lock();
1645 class WriteableScore {
1647 LDKWriteableScore self;
1649 WriteableScore(const WriteableScore&) = delete;
1650 WriteableScore(WriteableScore&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableScore)); }
1651 WriteableScore(LDKWriteableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableScore)); }
1652 operator LDKWriteableScore() && { LDKWriteableScore res = self; memset(&self, 0, sizeof(LDKWriteableScore)); return res; }
1653 ~WriteableScore() { WriteableScore_free(self); }
1654 WriteableScore& operator=(WriteableScore&& o) { WriteableScore_free(self); self = o.self; memset(&o, 0, sizeof(WriteableScore)); return *this; }
1655 LDKWriteableScore* operator &() { return &self; }
1656 LDKWriteableScore* operator ->() { return &self; }
1657 const LDKWriteableScore* operator &() const { return &self; }
1658 const LDKWriteableScore* operator ->() const { return &self; }
1660 class MultiThreadedLockableScore {
1662 LDKMultiThreadedLockableScore self;
1664 MultiThreadedLockableScore(const MultiThreadedLockableScore&) = delete;
1665 MultiThreadedLockableScore(MultiThreadedLockableScore&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedLockableScore)); }
1666 MultiThreadedLockableScore(LDKMultiThreadedLockableScore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedLockableScore)); }
1667 operator LDKMultiThreadedLockableScore() && { LDKMultiThreadedLockableScore res = self; memset(&self, 0, sizeof(LDKMultiThreadedLockableScore)); return res; }
1668 ~MultiThreadedLockableScore() { MultiThreadedLockableScore_free(self); }
1669 MultiThreadedLockableScore& operator=(MultiThreadedLockableScore&& o) { MultiThreadedLockableScore_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedLockableScore)); return *this; }
1670 LDKMultiThreadedLockableScore* operator &() { return &self; }
1671 LDKMultiThreadedLockableScore* operator ->() { return &self; }
1672 const LDKMultiThreadedLockableScore* operator &() const { return &self; }
1673 const LDKMultiThreadedLockableScore* operator ->() const { return &self; }
1675 class MultiThreadedScoreLockRead {
1677 LDKMultiThreadedScoreLockRead self;
1679 MultiThreadedScoreLockRead(const MultiThreadedScoreLockRead&) = delete;
1680 MultiThreadedScoreLockRead(MultiThreadedScoreLockRead&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); }
1681 MultiThreadedScoreLockRead(LDKMultiThreadedScoreLockRead&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockRead)); }
1682 operator LDKMultiThreadedScoreLockRead() && { LDKMultiThreadedScoreLockRead res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockRead)); return res; }
1683 ~MultiThreadedScoreLockRead() { MultiThreadedScoreLockRead_free(self); }
1684 MultiThreadedScoreLockRead& operator=(MultiThreadedScoreLockRead&& o) { MultiThreadedScoreLockRead_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockRead)); return *this; }
1685 LDKMultiThreadedScoreLockRead* operator &() { return &self; }
1686 LDKMultiThreadedScoreLockRead* operator ->() { return &self; }
1687 const LDKMultiThreadedScoreLockRead* operator &() const { return &self; }
1688 const LDKMultiThreadedScoreLockRead* operator ->() const { return &self; }
1690 class MultiThreadedScoreLockWrite {
1692 LDKMultiThreadedScoreLockWrite self;
1694 MultiThreadedScoreLockWrite(const MultiThreadedScoreLockWrite&) = delete;
1695 MultiThreadedScoreLockWrite(MultiThreadedScoreLockWrite&& o) : self(o.self) { memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); }
1696 MultiThreadedScoreLockWrite(LDKMultiThreadedScoreLockWrite&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); }
1697 operator LDKMultiThreadedScoreLockWrite() && { LDKMultiThreadedScoreLockWrite res = self; memset(&self, 0, sizeof(LDKMultiThreadedScoreLockWrite)); return res; }
1698 ~MultiThreadedScoreLockWrite() { MultiThreadedScoreLockWrite_free(self); }
1699 MultiThreadedScoreLockWrite& operator=(MultiThreadedScoreLockWrite&& o) { MultiThreadedScoreLockWrite_free(self); self = o.self; memset(&o, 0, sizeof(MultiThreadedScoreLockWrite)); return *this; }
1700 LDKMultiThreadedScoreLockWrite* operator &() { return &self; }
1701 LDKMultiThreadedScoreLockWrite* operator ->() { return &self; }
1702 const LDKMultiThreadedScoreLockWrite* operator &() const { return &self; }
1703 const LDKMultiThreadedScoreLockWrite* operator ->() const { return &self; }
1705 class ChannelUsage {
1707 LDKChannelUsage self;
1709 ChannelUsage(const ChannelUsage&) = delete;
1710 ChannelUsage(ChannelUsage&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUsage)); }
1711 ChannelUsage(LDKChannelUsage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUsage)); }
1712 operator LDKChannelUsage() && { LDKChannelUsage res = self; memset(&self, 0, sizeof(LDKChannelUsage)); return res; }
1713 ~ChannelUsage() { ChannelUsage_free(self); }
1714 ChannelUsage& operator=(ChannelUsage&& o) { ChannelUsage_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUsage)); return *this; }
1715 LDKChannelUsage* operator &() { return &self; }
1716 LDKChannelUsage* operator ->() { return &self; }
1717 const LDKChannelUsage* operator &() const { return &self; }
1718 const LDKChannelUsage* operator ->() const { return &self; }
1720 class FixedPenaltyScorer {
1722 LDKFixedPenaltyScorer self;
1724 FixedPenaltyScorer(const FixedPenaltyScorer&) = delete;
1725 FixedPenaltyScorer(FixedPenaltyScorer&& o) : self(o.self) { memset(&o, 0, sizeof(FixedPenaltyScorer)); }
1726 FixedPenaltyScorer(LDKFixedPenaltyScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFixedPenaltyScorer)); }
1727 operator LDKFixedPenaltyScorer() && { LDKFixedPenaltyScorer res = self; memset(&self, 0, sizeof(LDKFixedPenaltyScorer)); return res; }
1728 ~FixedPenaltyScorer() { FixedPenaltyScorer_free(self); }
1729 FixedPenaltyScorer& operator=(FixedPenaltyScorer&& o) { FixedPenaltyScorer_free(self); self = o.self; memset(&o, 0, sizeof(FixedPenaltyScorer)); return *this; }
1730 LDKFixedPenaltyScorer* operator &() { return &self; }
1731 LDKFixedPenaltyScorer* operator ->() { return &self; }
1732 const LDKFixedPenaltyScorer* operator &() const { return &self; }
1733 const LDKFixedPenaltyScorer* operator ->() const { return &self; }
1735 class ProbabilisticScorer {
1737 LDKProbabilisticScorer self;
1739 ProbabilisticScorer(const ProbabilisticScorer&) = delete;
1740 ProbabilisticScorer(ProbabilisticScorer&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScorer)); }
1741 ProbabilisticScorer(LDKProbabilisticScorer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScorer)); }
1742 operator LDKProbabilisticScorer() && { LDKProbabilisticScorer res = self; memset(&self, 0, sizeof(LDKProbabilisticScorer)); return res; }
1743 ~ProbabilisticScorer() { ProbabilisticScorer_free(self); }
1744 ProbabilisticScorer& operator=(ProbabilisticScorer&& o) { ProbabilisticScorer_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScorer)); return *this; }
1745 LDKProbabilisticScorer* operator &() { return &self; }
1746 LDKProbabilisticScorer* operator ->() { return &self; }
1747 const LDKProbabilisticScorer* operator &() const { return &self; }
1748 const LDKProbabilisticScorer* operator ->() const { return &self; }
1750 class ProbabilisticScoringFeeParameters {
1752 LDKProbabilisticScoringFeeParameters self;
1754 ProbabilisticScoringFeeParameters(const ProbabilisticScoringFeeParameters&) = delete;
1755 ProbabilisticScoringFeeParameters(ProbabilisticScoringFeeParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); }
1756 ProbabilisticScoringFeeParameters(LDKProbabilisticScoringFeeParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); }
1757 operator LDKProbabilisticScoringFeeParameters() && { LDKProbabilisticScoringFeeParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringFeeParameters)); return res; }
1758 ~ProbabilisticScoringFeeParameters() { ProbabilisticScoringFeeParameters_free(self); }
1759 ProbabilisticScoringFeeParameters& operator=(ProbabilisticScoringFeeParameters&& o) { ProbabilisticScoringFeeParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringFeeParameters)); return *this; }
1760 LDKProbabilisticScoringFeeParameters* operator &() { return &self; }
1761 LDKProbabilisticScoringFeeParameters* operator ->() { return &self; }
1762 const LDKProbabilisticScoringFeeParameters* operator &() const { return &self; }
1763 const LDKProbabilisticScoringFeeParameters* operator ->() const { return &self; }
1765 class ProbabilisticScoringDecayParameters {
1767 LDKProbabilisticScoringDecayParameters self;
1769 ProbabilisticScoringDecayParameters(const ProbabilisticScoringDecayParameters&) = delete;
1770 ProbabilisticScoringDecayParameters(ProbabilisticScoringDecayParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); }
1771 ProbabilisticScoringDecayParameters(LDKProbabilisticScoringDecayParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); }
1772 operator LDKProbabilisticScoringDecayParameters() && { LDKProbabilisticScoringDecayParameters res = self; memset(&self, 0, sizeof(LDKProbabilisticScoringDecayParameters)); return res; }
1773 ~ProbabilisticScoringDecayParameters() { ProbabilisticScoringDecayParameters_free(self); }
1774 ProbabilisticScoringDecayParameters& operator=(ProbabilisticScoringDecayParameters&& o) { ProbabilisticScoringDecayParameters_free(self); self = o.self; memset(&o, 0, sizeof(ProbabilisticScoringDecayParameters)); return *this; }
1775 LDKProbabilisticScoringDecayParameters* operator &() { return &self; }
1776 LDKProbabilisticScoringDecayParameters* operator ->() { return &self; }
1777 const LDKProbabilisticScoringDecayParameters* operator &() const { return &self; }
1778 const LDKProbabilisticScoringDecayParameters* operator ->() const { return &self; }
1784 BestBlock(const BestBlock&) = delete;
1785 BestBlock(BestBlock&& o) : self(o.self) { memset(&o, 0, sizeof(BestBlock)); }
1786 BestBlock(LDKBestBlock&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBestBlock)); }
1787 operator LDKBestBlock() && { LDKBestBlock res = self; memset(&self, 0, sizeof(LDKBestBlock)); return res; }
1788 ~BestBlock() { BestBlock_free(self); }
1789 BestBlock& operator=(BestBlock&& o) { BestBlock_free(self); self = o.self; memset(&o, 0, sizeof(BestBlock)); return *this; }
1790 LDKBestBlock* operator &() { return &self; }
1791 LDKBestBlock* operator ->() { return &self; }
1792 const LDKBestBlock* operator &() const { return &self; }
1793 const LDKBestBlock* operator ->() const { return &self; }
1799 Listen(const Listen&) = delete;
1800 Listen(Listen&& o) : self(o.self) { memset(&o, 0, sizeof(Listen)); }
1801 Listen(LDKListen&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKListen)); }
1802 operator LDKListen() && { LDKListen res = self; memset(&self, 0, sizeof(LDKListen)); return res; }
1803 ~Listen() { Listen_free(self); }
1804 Listen& operator=(Listen&& o) { Listen_free(self); self = o.self; memset(&o, 0, sizeof(Listen)); return *this; }
1805 LDKListen* operator &() { return &self; }
1806 LDKListen* operator ->() { return &self; }
1807 const LDKListen* operator &() const { return &self; }
1808 const LDKListen* operator ->() const { return &self; }
1810 * Notifies the listener that a block was added at the given height, with the transaction data
1811 * possibly filtered.
1813 inline void filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1815 * Notifies the listener that a block was added at the given height.
1817 inline void block_connected(struct LDKu8slice block, uint32_t height);
1819 * Notifies the listener that a block was removed at the given height.
1821 inline void block_disconnected(const uint8_t (*header)[80], uint32_t height);
1827 Confirm(const Confirm&) = delete;
1828 Confirm(Confirm&& o) : self(o.self) { memset(&o, 0, sizeof(Confirm)); }
1829 Confirm(LDKConfirm&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirm)); }
1830 operator LDKConfirm() && { LDKConfirm res = self; memset(&self, 0, sizeof(LDKConfirm)); return res; }
1831 ~Confirm() { Confirm_free(self); }
1832 Confirm& operator=(Confirm&& o) { Confirm_free(self); self = o.self; memset(&o, 0, sizeof(Confirm)); return *this; }
1833 LDKConfirm* operator &() { return &self; }
1834 LDKConfirm* operator ->() { return &self; }
1835 const LDKConfirm* operator &() const { return &self; }
1836 const LDKConfirm* operator ->() const { return &self; }
1838 * Notifies LDK of transactions confirmed in a block with a given header and height.
1840 * Must be called for any transactions registered by [`Filter::register_tx`] or any
1841 * transactions spending an output registered by [`Filter::register_output`]. Such transactions
1842 * appearing in the same block do not need to be included in the same call; instead, multiple
1843 * calls with additional transactions may be made so long as they are made in [chain order].
1845 * May be called before or after [`best_block_updated`] for the corresponding block. However,
1846 * in the event of a chain reorganization, it must not be called with a `header` that is no
1847 * longer in the chain as of the last call to [`best_block_updated`].
1849 * [chain order]: Confirm#order
1850 * [`best_block_updated`]: Self::best_block_updated
1852 inline void transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
1854 * Notifies LDK of a transaction that is no longer confirmed as result of a chain reorganization.
1856 * Must be called for any transaction returned by [`get_relevant_txids`] if it has been
1857 * reorganized out of the best chain or if it is no longer confirmed in the block with the
1858 * given block hash. Once called, the given transaction will not be returned
1859 * by [`get_relevant_txids`], unless it has been reconfirmed via [`transactions_confirmed`].
1861 * [`get_relevant_txids`]: Self::get_relevant_txids
1862 * [`transactions_confirmed`]: Self::transactions_confirmed
1864 inline void transaction_unconfirmed(const uint8_t (*txid)[32]);
1866 * Notifies LDK of an update to the best header connected at the given height.
1868 * Must be called whenever a new chain tip becomes available. May be skipped for intermediary
1871 inline void best_block_updated(const uint8_t (*header)[80], uint32_t height);
1873 * Returns transactions that must be monitored for reorganization out of the chain along
1874 * with the height and the hash of the block as part of which it had been previously confirmed.
1876 * Note that the returned `Option<BlockHash>` might be `None` for channels created with LDK
1877 * 0.0.112 and prior, in which case you need to manually track previous confirmations.
1879 * Will include any transactions passed to [`transactions_confirmed`] that have insufficient
1880 * confirmations to be safe from a chain reorganization. Will not include any transactions
1881 * passed to [`transaction_unconfirmed`], unless later reconfirmed.
1883 * Must be called to determine the subset of transactions that must be monitored for
1884 * reorganization. Will be idempotent between calls but may change as a result of calls to the
1885 * other interface methods. Thus, this is useful to determine which transactions must be
1886 * given to [`transaction_unconfirmed`].
1888 * If any of the returned transactions are confirmed in a block other than the one with the
1889 * given hash at the given height, they need to be unconfirmed and reconfirmed via
1890 * [`transaction_unconfirmed`] and [`transactions_confirmed`], respectively.
1892 * [`transactions_confirmed`]: Self::transactions_confirmed
1893 * [`transaction_unconfirmed`]: Self::transaction_unconfirmed
1895 inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ get_relevant_txids();
1897 class ChannelMonitorUpdateStatus {
1899 LDKChannelMonitorUpdateStatus self;
1901 ChannelMonitorUpdateStatus(const ChannelMonitorUpdateStatus&) = delete;
1902 ChannelMonitorUpdateStatus(ChannelMonitorUpdateStatus&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); }
1903 ChannelMonitorUpdateStatus(LDKChannelMonitorUpdateStatus&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdateStatus)); }
1904 operator LDKChannelMonitorUpdateStatus() && { LDKChannelMonitorUpdateStatus res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdateStatus)); return res; }
1905 ChannelMonitorUpdateStatus& operator=(ChannelMonitorUpdateStatus&& o) { self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdateStatus)); return *this; }
1906 LDKChannelMonitorUpdateStatus* operator &() { return &self; }
1907 LDKChannelMonitorUpdateStatus* operator ->() { return &self; }
1908 const LDKChannelMonitorUpdateStatus* operator &() const { return &self; }
1909 const LDKChannelMonitorUpdateStatus* operator ->() const { return &self; }
1915 Watch(const Watch&) = delete;
1916 Watch(Watch&& o) : self(o.self) { memset(&o, 0, sizeof(Watch)); }
1917 Watch(LDKWatch&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatch)); }
1918 operator LDKWatch() && { LDKWatch res = self; memset(&self, 0, sizeof(LDKWatch)); return res; }
1919 ~Watch() { Watch_free(self); }
1920 Watch& operator=(Watch&& o) { Watch_free(self); self = o.self; memset(&o, 0, sizeof(Watch)); return *this; }
1921 LDKWatch* operator &() { return &self; }
1922 LDKWatch* operator ->() { return &self; }
1923 const LDKWatch* operator &() const { return &self; }
1924 const LDKWatch* operator ->() const { return &self; }
1926 * Watches a channel identified by `funding_txo` using `monitor`.
1928 * Implementations are responsible for watching the chain for the funding transaction along
1929 * with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
1930 * calling [`block_connected`] and [`block_disconnected`] on the monitor.
1932 * A return of `Err(())` indicates that the channel should immediately be force-closed without
1933 * broadcasting the funding transaction.
1935 * If the given `funding_txo` has previously been registered via `watch_channel`, `Err(())`
1938 * [`get_outputs_to_watch`]: channelmonitor::ChannelMonitor::get_outputs_to_watch
1939 * [`block_connected`]: channelmonitor::ChannelMonitor::block_connected
1940 * [`block_disconnected`]: channelmonitor::ChannelMonitor::block_disconnected
1942 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor);
1944 * Updates a channel identified by `funding_txo` by applying `update` to its monitor.
1946 * Implementations must call [`ChannelMonitor::update_monitor`] with the given update. This
1947 * may fail (returning an `Err(())`), in which case this should return
1948 * [`ChannelMonitorUpdateStatus::InProgress`] (and the update should never complete). This
1949 * generally implies the channel has been closed (either by the funding outpoint being spent
1950 * on-chain or the [`ChannelMonitor`] having decided to do so and broadcasted a transaction),
1951 * and the [`ChannelManager`] state will be updated once it sees the funding spend on-chain.
1953 * In general, persistence failures should be retried after returning
1954 * [`ChannelMonitorUpdateStatus::InProgress`] and eventually complete. If a failure truly
1955 * cannot be retried, the node should shut down immediately after returning
1956 * [`ChannelMonitorUpdateStatus::UnrecoverableError`], see its documentation for more info.
1958 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
1960 inline LDK::ChannelMonitorUpdateStatus update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update);
1962 * Returns any monitor events since the last call. Subsequent calls must only return new
1965 * Note that after any block- or transaction-connection calls to a [`ChannelMonitor`], no
1966 * further events may be returned here until the [`ChannelMonitor`] has been fully persisted
1969 * For details on asynchronous [`ChannelMonitor`] updating and returning
1970 * [`MonitorEvent::Completed`] here, see [`ChannelMonitorUpdateStatus::InProgress`].
1972 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events();
1978 Filter(const Filter&) = delete;
1979 Filter(Filter&& o) : self(o.self) { memset(&o, 0, sizeof(Filter)); }
1980 Filter(LDKFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilter)); }
1981 operator LDKFilter() && { LDKFilter res = self; memset(&self, 0, sizeof(LDKFilter)); return res; }
1982 ~Filter() { Filter_free(self); }
1983 Filter& operator=(Filter&& o) { Filter_free(self); self = o.self; memset(&o, 0, sizeof(Filter)); return *this; }
1984 LDKFilter* operator &() { return &self; }
1985 LDKFilter* operator ->() { return &self; }
1986 const LDKFilter* operator &() const { return &self; }
1987 const LDKFilter* operator ->() const { return &self; }
1989 * Registers interest in a transaction with `txid` and having an output with `script_pubkey` as
1990 * a spending condition.
1992 inline void register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey);
1994 * Registers interest in spends of a transaction output.
1996 * Note that this method might be called during processing of a new block. You therefore need
1997 * to ensure that also dependent output spents within an already connected block are correctly
1998 * handled, e.g., by re-scanning the block in question whenever new outputs have been
1999 * registered mid-processing.
2001 inline void register_output(struct LDKWatchedOutput output);
2003 class WatchedOutput {
2005 LDKWatchedOutput self;
2007 WatchedOutput(const WatchedOutput&) = delete;
2008 WatchedOutput(WatchedOutput&& o) : self(o.self) { memset(&o, 0, sizeof(WatchedOutput)); }
2009 WatchedOutput(LDKWatchedOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWatchedOutput)); }
2010 operator LDKWatchedOutput() && { LDKWatchedOutput res = self; memset(&self, 0, sizeof(LDKWatchedOutput)); return res; }
2011 ~WatchedOutput() { WatchedOutput_free(self); }
2012 WatchedOutput& operator=(WatchedOutput&& o) { WatchedOutput_free(self); self = o.self; memset(&o, 0, sizeof(WatchedOutput)); return *this; }
2013 LDKWatchedOutput* operator &() { return &self; }
2014 LDKWatchedOutput* operator ->() { return &self; }
2015 const LDKWatchedOutput* operator &() const { return &self; }
2016 const LDKWatchedOutput* operator ->() const { return &self; }
2018 class InitFeatures {
2020 LDKInitFeatures self;
2022 InitFeatures(const InitFeatures&) = delete;
2023 InitFeatures(InitFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InitFeatures)); }
2024 InitFeatures(LDKInitFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInitFeatures)); }
2025 operator LDKInitFeatures() && { LDKInitFeatures res = self; memset(&self, 0, sizeof(LDKInitFeatures)); return res; }
2026 ~InitFeatures() { InitFeatures_free(self); }
2027 InitFeatures& operator=(InitFeatures&& o) { InitFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InitFeatures)); return *this; }
2028 LDKInitFeatures* operator &() { return &self; }
2029 LDKInitFeatures* operator ->() { return &self; }
2030 const LDKInitFeatures* operator &() const { return &self; }
2031 const LDKInitFeatures* operator ->() const { return &self; }
2033 class NodeFeatures {
2035 LDKNodeFeatures self;
2037 NodeFeatures(const NodeFeatures&) = delete;
2038 NodeFeatures(NodeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(NodeFeatures)); }
2039 NodeFeatures(LDKNodeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeFeatures)); }
2040 operator LDKNodeFeatures() && { LDKNodeFeatures res = self; memset(&self, 0, sizeof(LDKNodeFeatures)); return res; }
2041 ~NodeFeatures() { NodeFeatures_free(self); }
2042 NodeFeatures& operator=(NodeFeatures&& o) { NodeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(NodeFeatures)); return *this; }
2043 LDKNodeFeatures* operator &() { return &self; }
2044 LDKNodeFeatures* operator ->() { return &self; }
2045 const LDKNodeFeatures* operator &() const { return &self; }
2046 const LDKNodeFeatures* operator ->() const { return &self; }
2048 class ChannelFeatures {
2050 LDKChannelFeatures self;
2052 ChannelFeatures(const ChannelFeatures&) = delete;
2053 ChannelFeatures(ChannelFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelFeatures)); }
2054 ChannelFeatures(LDKChannelFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelFeatures)); }
2055 operator LDKChannelFeatures() && { LDKChannelFeatures res = self; memset(&self, 0, sizeof(LDKChannelFeatures)); return res; }
2056 ~ChannelFeatures() { ChannelFeatures_free(self); }
2057 ChannelFeatures& operator=(ChannelFeatures&& o) { ChannelFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelFeatures)); return *this; }
2058 LDKChannelFeatures* operator &() { return &self; }
2059 LDKChannelFeatures* operator ->() { return &self; }
2060 const LDKChannelFeatures* operator &() const { return &self; }
2061 const LDKChannelFeatures* operator ->() const { return &self; }
2063 class Bolt11InvoiceFeatures {
2065 LDKBolt11InvoiceFeatures self;
2067 Bolt11InvoiceFeatures(const Bolt11InvoiceFeatures&) = delete;
2068 Bolt11InvoiceFeatures(Bolt11InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); }
2069 Bolt11InvoiceFeatures(LDKBolt11InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceFeatures)); }
2070 operator LDKBolt11InvoiceFeatures() && { LDKBolt11InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceFeatures)); return res; }
2071 ~Bolt11InvoiceFeatures() { Bolt11InvoiceFeatures_free(self); }
2072 Bolt11InvoiceFeatures& operator=(Bolt11InvoiceFeatures&& o) { Bolt11InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceFeatures)); return *this; }
2073 LDKBolt11InvoiceFeatures* operator &() { return &self; }
2074 LDKBolt11InvoiceFeatures* operator ->() { return &self; }
2075 const LDKBolt11InvoiceFeatures* operator &() const { return &self; }
2076 const LDKBolt11InvoiceFeatures* operator ->() const { return &self; }
2078 class OfferFeatures {
2080 LDKOfferFeatures self;
2082 OfferFeatures(const OfferFeatures&) = delete;
2083 OfferFeatures(OfferFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(OfferFeatures)); }
2084 OfferFeatures(LDKOfferFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOfferFeatures)); }
2085 operator LDKOfferFeatures() && { LDKOfferFeatures res = self; memset(&self, 0, sizeof(LDKOfferFeatures)); return res; }
2086 ~OfferFeatures() { OfferFeatures_free(self); }
2087 OfferFeatures& operator=(OfferFeatures&& o) { OfferFeatures_free(self); self = o.self; memset(&o, 0, sizeof(OfferFeatures)); return *this; }
2088 LDKOfferFeatures* operator &() { return &self; }
2089 LDKOfferFeatures* operator ->() { return &self; }
2090 const LDKOfferFeatures* operator &() const { return &self; }
2091 const LDKOfferFeatures* operator ->() const { return &self; }
2093 class InvoiceRequestFeatures {
2095 LDKInvoiceRequestFeatures self;
2097 InvoiceRequestFeatures(const InvoiceRequestFeatures&) = delete;
2098 InvoiceRequestFeatures(InvoiceRequestFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequestFeatures)); }
2099 InvoiceRequestFeatures(LDKInvoiceRequestFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequestFeatures)); }
2100 operator LDKInvoiceRequestFeatures() && { LDKInvoiceRequestFeatures res = self; memset(&self, 0, sizeof(LDKInvoiceRequestFeatures)); return res; }
2101 ~InvoiceRequestFeatures() { InvoiceRequestFeatures_free(self); }
2102 InvoiceRequestFeatures& operator=(InvoiceRequestFeatures&& o) { InvoiceRequestFeatures_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequestFeatures)); return *this; }
2103 LDKInvoiceRequestFeatures* operator &() { return &self; }
2104 LDKInvoiceRequestFeatures* operator ->() { return &self; }
2105 const LDKInvoiceRequestFeatures* operator &() const { return &self; }
2106 const LDKInvoiceRequestFeatures* operator ->() const { return &self; }
2108 class Bolt12InvoiceFeatures {
2110 LDKBolt12InvoiceFeatures self;
2112 Bolt12InvoiceFeatures(const Bolt12InvoiceFeatures&) = delete;
2113 Bolt12InvoiceFeatures(Bolt12InvoiceFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); }
2114 Bolt12InvoiceFeatures(LDKBolt12InvoiceFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12InvoiceFeatures)); }
2115 operator LDKBolt12InvoiceFeatures() && { LDKBolt12InvoiceFeatures res = self; memset(&self, 0, sizeof(LDKBolt12InvoiceFeatures)); return res; }
2116 ~Bolt12InvoiceFeatures() { Bolt12InvoiceFeatures_free(self); }
2117 Bolt12InvoiceFeatures& operator=(Bolt12InvoiceFeatures&& o) { Bolt12InvoiceFeatures_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12InvoiceFeatures)); return *this; }
2118 LDKBolt12InvoiceFeatures* operator &() { return &self; }
2119 LDKBolt12InvoiceFeatures* operator ->() { return &self; }
2120 const LDKBolt12InvoiceFeatures* operator &() const { return &self; }
2121 const LDKBolt12InvoiceFeatures* operator ->() const { return &self; }
2123 class BlindedHopFeatures {
2125 LDKBlindedHopFeatures self;
2127 BlindedHopFeatures(const BlindedHopFeatures&) = delete;
2128 BlindedHopFeatures(BlindedHopFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHopFeatures)); }
2129 BlindedHopFeatures(LDKBlindedHopFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHopFeatures)); }
2130 operator LDKBlindedHopFeatures() && { LDKBlindedHopFeatures res = self; memset(&self, 0, sizeof(LDKBlindedHopFeatures)); return res; }
2131 ~BlindedHopFeatures() { BlindedHopFeatures_free(self); }
2132 BlindedHopFeatures& operator=(BlindedHopFeatures&& o) { BlindedHopFeatures_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHopFeatures)); return *this; }
2133 LDKBlindedHopFeatures* operator &() { return &self; }
2134 LDKBlindedHopFeatures* operator ->() { return &self; }
2135 const LDKBlindedHopFeatures* operator &() const { return &self; }
2136 const LDKBlindedHopFeatures* operator ->() const { return &self; }
2138 class ChannelTypeFeatures {
2140 LDKChannelTypeFeatures self;
2142 ChannelTypeFeatures(const ChannelTypeFeatures&) = delete;
2143 ChannelTypeFeatures(ChannelTypeFeatures&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTypeFeatures)); }
2144 ChannelTypeFeatures(LDKChannelTypeFeatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTypeFeatures)); }
2145 operator LDKChannelTypeFeatures() && { LDKChannelTypeFeatures res = self; memset(&self, 0, sizeof(LDKChannelTypeFeatures)); return res; }
2146 ~ChannelTypeFeatures() { ChannelTypeFeatures_free(self); }
2147 ChannelTypeFeatures& operator=(ChannelTypeFeatures&& o) { ChannelTypeFeatures_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTypeFeatures)); return *this; }
2148 LDKChannelTypeFeatures* operator &() { return &self; }
2149 LDKChannelTypeFeatures* operator ->() { return &self; }
2150 const LDKChannelTypeFeatures* operator &() const { return &self; }
2151 const LDKChannelTypeFeatures* operator ->() const { return &self; }
2157 Offer(const Offer&) = delete;
2158 Offer(Offer&& o) : self(o.self) { memset(&o, 0, sizeof(Offer)); }
2159 Offer(LDKOffer&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffer)); }
2160 operator LDKOffer() && { LDKOffer res = self; memset(&self, 0, sizeof(LDKOffer)); return res; }
2161 ~Offer() { Offer_free(self); }
2162 Offer& operator=(Offer&& o) { Offer_free(self); self = o.self; memset(&o, 0, sizeof(Offer)); return *this; }
2163 LDKOffer* operator &() { return &self; }
2164 LDKOffer* operator ->() { return &self; }
2165 const LDKOffer* operator &() const { return &self; }
2166 const LDKOffer* operator ->() const { return &self; }
2172 Amount(const Amount&) = delete;
2173 Amount(Amount&& o) : self(o.self) { memset(&o, 0, sizeof(Amount)); }
2174 Amount(LDKAmount&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAmount)); }
2175 operator LDKAmount() && { LDKAmount res = self; memset(&self, 0, sizeof(LDKAmount)); return res; }
2176 ~Amount() { Amount_free(self); }
2177 Amount& operator=(Amount&& o) { Amount_free(self); self = o.self; memset(&o, 0, sizeof(Amount)); return *this; }
2178 LDKAmount* operator &() { return &self; }
2179 LDKAmount* operator ->() { return &self; }
2180 const LDKAmount* operator &() const { return &self; }
2181 const LDKAmount* operator ->() const { return &self; }
2187 Quantity(const Quantity&) = delete;
2188 Quantity(Quantity&& o) : self(o.self) { memset(&o, 0, sizeof(Quantity)); }
2189 Quantity(LDKQuantity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQuantity)); }
2190 operator LDKQuantity() && { LDKQuantity res = self; memset(&self, 0, sizeof(LDKQuantity)); return res; }
2191 ~Quantity() { Quantity_free(self); }
2192 Quantity& operator=(Quantity&& o) { Quantity_free(self); self = o.self; memset(&o, 0, sizeof(Quantity)); return *this; }
2193 LDKQuantity* operator &() { return &self; }
2194 LDKQuantity* operator ->() { return &self; }
2195 const LDKQuantity* operator &() const { return &self; }
2196 const LDKQuantity* operator ->() const { return &self; }
2202 NodeId(const NodeId&) = delete;
2203 NodeId(NodeId&& o) : self(o.self) { memset(&o, 0, sizeof(NodeId)); }
2204 NodeId(LDKNodeId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeId)); }
2205 operator LDKNodeId() && { LDKNodeId res = self; memset(&self, 0, sizeof(LDKNodeId)); return res; }
2206 ~NodeId() { NodeId_free(self); }
2207 NodeId& operator=(NodeId&& o) { NodeId_free(self); self = o.self; memset(&o, 0, sizeof(NodeId)); return *this; }
2208 LDKNodeId* operator &() { return &self; }
2209 LDKNodeId* operator ->() { return &self; }
2210 const LDKNodeId* operator &() const { return &self; }
2211 const LDKNodeId* operator ->() const { return &self; }
2213 class NetworkGraph {
2215 LDKNetworkGraph self;
2217 NetworkGraph(const NetworkGraph&) = delete;
2218 NetworkGraph(NetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkGraph)); }
2219 NetworkGraph(LDKNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkGraph)); }
2220 operator LDKNetworkGraph() && { LDKNetworkGraph res = self; memset(&self, 0, sizeof(LDKNetworkGraph)); return res; }
2221 ~NetworkGraph() { NetworkGraph_free(self); }
2222 NetworkGraph& operator=(NetworkGraph&& o) { NetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(NetworkGraph)); return *this; }
2223 LDKNetworkGraph* operator &() { return &self; }
2224 LDKNetworkGraph* operator ->() { return &self; }
2225 const LDKNetworkGraph* operator &() const { return &self; }
2226 const LDKNetworkGraph* operator ->() const { return &self; }
2228 class ReadOnlyNetworkGraph {
2230 LDKReadOnlyNetworkGraph self;
2232 ReadOnlyNetworkGraph(const ReadOnlyNetworkGraph&) = delete;
2233 ReadOnlyNetworkGraph(ReadOnlyNetworkGraph&& o) : self(o.self) { memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); }
2234 ReadOnlyNetworkGraph(LDKReadOnlyNetworkGraph&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReadOnlyNetworkGraph)); }
2235 operator LDKReadOnlyNetworkGraph() && { LDKReadOnlyNetworkGraph res = self; memset(&self, 0, sizeof(LDKReadOnlyNetworkGraph)); return res; }
2236 ~ReadOnlyNetworkGraph() { ReadOnlyNetworkGraph_free(self); }
2237 ReadOnlyNetworkGraph& operator=(ReadOnlyNetworkGraph&& o) { ReadOnlyNetworkGraph_free(self); self = o.self; memset(&o, 0, sizeof(ReadOnlyNetworkGraph)); return *this; }
2238 LDKReadOnlyNetworkGraph* operator &() { return &self; }
2239 LDKReadOnlyNetworkGraph* operator ->() { return &self; }
2240 const LDKReadOnlyNetworkGraph* operator &() const { return &self; }
2241 const LDKReadOnlyNetworkGraph* operator ->() const { return &self; }
2243 class NetworkUpdate {
2245 LDKNetworkUpdate self;
2247 NetworkUpdate(const NetworkUpdate&) = delete;
2248 NetworkUpdate(NetworkUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(NetworkUpdate)); }
2249 NetworkUpdate(LDKNetworkUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNetworkUpdate)); }
2250 operator LDKNetworkUpdate() && { LDKNetworkUpdate res = self; memset(&self, 0, sizeof(LDKNetworkUpdate)); return res; }
2251 ~NetworkUpdate() { NetworkUpdate_free(self); }
2252 NetworkUpdate& operator=(NetworkUpdate&& o) { NetworkUpdate_free(self); self = o.self; memset(&o, 0, sizeof(NetworkUpdate)); return *this; }
2253 LDKNetworkUpdate* operator &() { return &self; }
2254 LDKNetworkUpdate* operator ->() { return &self; }
2255 const LDKNetworkUpdate* operator &() const { return &self; }
2256 const LDKNetworkUpdate* operator ->() const { return &self; }
2258 class P2PGossipSync {
2260 LDKP2PGossipSync self;
2262 P2PGossipSync(const P2PGossipSync&) = delete;
2263 P2PGossipSync(P2PGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(P2PGossipSync)); }
2264 P2PGossipSync(LDKP2PGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKP2PGossipSync)); }
2265 operator LDKP2PGossipSync() && { LDKP2PGossipSync res = self; memset(&self, 0, sizeof(LDKP2PGossipSync)); return res; }
2266 ~P2PGossipSync() { P2PGossipSync_free(self); }
2267 P2PGossipSync& operator=(P2PGossipSync&& o) { P2PGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(P2PGossipSync)); return *this; }
2268 LDKP2PGossipSync* operator &() { return &self; }
2269 LDKP2PGossipSync* operator ->() { return &self; }
2270 const LDKP2PGossipSync* operator &() const { return &self; }
2271 const LDKP2PGossipSync* operator ->() const { return &self; }
2273 class ChannelUpdateInfo {
2275 LDKChannelUpdateInfo self;
2277 ChannelUpdateInfo(const ChannelUpdateInfo&) = delete;
2278 ChannelUpdateInfo(ChannelUpdateInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdateInfo)); }
2279 ChannelUpdateInfo(LDKChannelUpdateInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdateInfo)); }
2280 operator LDKChannelUpdateInfo() && { LDKChannelUpdateInfo res = self; memset(&self, 0, sizeof(LDKChannelUpdateInfo)); return res; }
2281 ~ChannelUpdateInfo() { ChannelUpdateInfo_free(self); }
2282 ChannelUpdateInfo& operator=(ChannelUpdateInfo&& o) { ChannelUpdateInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdateInfo)); return *this; }
2283 LDKChannelUpdateInfo* operator &() { return &self; }
2284 LDKChannelUpdateInfo* operator ->() { return &self; }
2285 const LDKChannelUpdateInfo* operator &() const { return &self; }
2286 const LDKChannelUpdateInfo* operator ->() const { return &self; }
2290 LDKChannelInfo self;
2292 ChannelInfo(const ChannelInfo&) = delete;
2293 ChannelInfo(ChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelInfo)); }
2294 ChannelInfo(LDKChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelInfo)); }
2295 operator LDKChannelInfo() && { LDKChannelInfo res = self; memset(&self, 0, sizeof(LDKChannelInfo)); return res; }
2296 ~ChannelInfo() { ChannelInfo_free(self); }
2297 ChannelInfo& operator=(ChannelInfo&& o) { ChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(ChannelInfo)); return *this; }
2298 LDKChannelInfo* operator &() { return &self; }
2299 LDKChannelInfo* operator ->() { return &self; }
2300 const LDKChannelInfo* operator &() const { return &self; }
2301 const LDKChannelInfo* operator ->() const { return &self; }
2303 class DirectedChannelInfo {
2305 LDKDirectedChannelInfo self;
2307 DirectedChannelInfo(const DirectedChannelInfo&) = delete;
2308 DirectedChannelInfo(DirectedChannelInfo&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelInfo)); }
2309 DirectedChannelInfo(LDKDirectedChannelInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelInfo)); }
2310 operator LDKDirectedChannelInfo() && { LDKDirectedChannelInfo res = self; memset(&self, 0, sizeof(LDKDirectedChannelInfo)); return res; }
2311 ~DirectedChannelInfo() { DirectedChannelInfo_free(self); }
2312 DirectedChannelInfo& operator=(DirectedChannelInfo&& o) { DirectedChannelInfo_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelInfo)); return *this; }
2313 LDKDirectedChannelInfo* operator &() { return &self; }
2314 LDKDirectedChannelInfo* operator ->() { return &self; }
2315 const LDKDirectedChannelInfo* operator &() const { return &self; }
2316 const LDKDirectedChannelInfo* operator ->() const { return &self; }
2318 class EffectiveCapacity {
2320 LDKEffectiveCapacity self;
2322 EffectiveCapacity(const EffectiveCapacity&) = delete;
2323 EffectiveCapacity(EffectiveCapacity&& o) : self(o.self) { memset(&o, 0, sizeof(EffectiveCapacity)); }
2324 EffectiveCapacity(LDKEffectiveCapacity&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEffectiveCapacity)); }
2325 operator LDKEffectiveCapacity() && { LDKEffectiveCapacity res = self; memset(&self, 0, sizeof(LDKEffectiveCapacity)); return res; }
2326 ~EffectiveCapacity() { EffectiveCapacity_free(self); }
2327 EffectiveCapacity& operator=(EffectiveCapacity&& o) { EffectiveCapacity_free(self); self = o.self; memset(&o, 0, sizeof(EffectiveCapacity)); return *this; }
2328 LDKEffectiveCapacity* operator &() { return &self; }
2329 LDKEffectiveCapacity* operator ->() { return &self; }
2330 const LDKEffectiveCapacity* operator &() const { return &self; }
2331 const LDKEffectiveCapacity* operator ->() const { return &self; }
2335 LDKRoutingFees self;
2337 RoutingFees(const RoutingFees&) = delete;
2338 RoutingFees(RoutingFees&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingFees)); }
2339 RoutingFees(LDKRoutingFees&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingFees)); }
2340 operator LDKRoutingFees() && { LDKRoutingFees res = self; memset(&self, 0, sizeof(LDKRoutingFees)); return res; }
2341 ~RoutingFees() { RoutingFees_free(self); }
2342 RoutingFees& operator=(RoutingFees&& o) { RoutingFees_free(self); self = o.self; memset(&o, 0, sizeof(RoutingFees)); return *this; }
2343 LDKRoutingFees* operator &() { return &self; }
2344 LDKRoutingFees* operator ->() { return &self; }
2345 const LDKRoutingFees* operator &() const { return &self; }
2346 const LDKRoutingFees* operator ->() const { return &self; }
2348 class NodeAnnouncementInfo {
2350 LDKNodeAnnouncementInfo self;
2352 NodeAnnouncementInfo(const NodeAnnouncementInfo&) = delete;
2353 NodeAnnouncementInfo(NodeAnnouncementInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncementInfo)); }
2354 NodeAnnouncementInfo(LDKNodeAnnouncementInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncementInfo)); }
2355 operator LDKNodeAnnouncementInfo() && { LDKNodeAnnouncementInfo res = self; memset(&self, 0, sizeof(LDKNodeAnnouncementInfo)); return res; }
2356 ~NodeAnnouncementInfo() { NodeAnnouncementInfo_free(self); }
2357 NodeAnnouncementInfo& operator=(NodeAnnouncementInfo&& o) { NodeAnnouncementInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncementInfo)); return *this; }
2358 LDKNodeAnnouncementInfo* operator &() { return &self; }
2359 LDKNodeAnnouncementInfo* operator ->() { return &self; }
2360 const LDKNodeAnnouncementInfo* operator &() const { return &self; }
2361 const LDKNodeAnnouncementInfo* operator ->() const { return &self; }
2367 NodeAlias(const NodeAlias&) = delete;
2368 NodeAlias(NodeAlias&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAlias)); }
2369 NodeAlias(LDKNodeAlias&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAlias)); }
2370 operator LDKNodeAlias() && { LDKNodeAlias res = self; memset(&self, 0, sizeof(LDKNodeAlias)); return res; }
2371 ~NodeAlias() { NodeAlias_free(self); }
2372 NodeAlias& operator=(NodeAlias&& o) { NodeAlias_free(self); self = o.self; memset(&o, 0, sizeof(NodeAlias)); return *this; }
2373 LDKNodeAlias* operator &() { return &self; }
2374 LDKNodeAlias* operator ->() { return &self; }
2375 const LDKNodeAlias* operator &() const { return &self; }
2376 const LDKNodeAlias* operator ->() const { return &self; }
2382 NodeInfo(const NodeInfo&) = delete;
2383 NodeInfo(NodeInfo&& o) : self(o.self) { memset(&o, 0, sizeof(NodeInfo)); }
2384 NodeInfo(LDKNodeInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeInfo)); }
2385 operator LDKNodeInfo() && { LDKNodeInfo res = self; memset(&self, 0, sizeof(LDKNodeInfo)); return res; }
2386 ~NodeInfo() { NodeInfo_free(self); }
2387 NodeInfo& operator=(NodeInfo&& o) { NodeInfo_free(self); self = o.self; memset(&o, 0, sizeof(NodeInfo)); return *this; }
2388 LDKNodeInfo* operator &() { return &self; }
2389 LDKNodeInfo* operator ->() { return &self; }
2390 const LDKNodeInfo* operator &() const { return &self; }
2391 const LDKNodeInfo* operator ->() const { return &self; }
2393 class InboundHTLCErr {
2395 LDKInboundHTLCErr self;
2397 InboundHTLCErr(const InboundHTLCErr&) = delete;
2398 InboundHTLCErr(InboundHTLCErr&& o) : self(o.self) { memset(&o, 0, sizeof(InboundHTLCErr)); }
2399 InboundHTLCErr(LDKInboundHTLCErr&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInboundHTLCErr)); }
2400 operator LDKInboundHTLCErr() && { LDKInboundHTLCErr res = self; memset(&self, 0, sizeof(LDKInboundHTLCErr)); return res; }
2401 ~InboundHTLCErr() { InboundHTLCErr_free(self); }
2402 InboundHTLCErr& operator=(InboundHTLCErr&& o) { InboundHTLCErr_free(self); self = o.self; memset(&o, 0, sizeof(InboundHTLCErr)); return *this; }
2403 LDKInboundHTLCErr* operator &() { return &self; }
2404 LDKInboundHTLCErr* operator ->() { return &self; }
2405 const LDKInboundHTLCErr* operator &() const { return &self; }
2406 const LDKInboundHTLCErr* operator ->() const { return &self; }
2408 class AnchorDescriptor {
2410 LDKAnchorDescriptor self;
2412 AnchorDescriptor(const AnchorDescriptor&) = delete;
2413 AnchorDescriptor(AnchorDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(AnchorDescriptor)); }
2414 AnchorDescriptor(LDKAnchorDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnchorDescriptor)); }
2415 operator LDKAnchorDescriptor() && { LDKAnchorDescriptor res = self; memset(&self, 0, sizeof(LDKAnchorDescriptor)); return res; }
2416 ~AnchorDescriptor() { AnchorDescriptor_free(self); }
2417 AnchorDescriptor& operator=(AnchorDescriptor&& o) { AnchorDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(AnchorDescriptor)); return *this; }
2418 LDKAnchorDescriptor* operator &() { return &self; }
2419 LDKAnchorDescriptor* operator ->() { return &self; }
2420 const LDKAnchorDescriptor* operator &() const { return &self; }
2421 const LDKAnchorDescriptor* operator ->() const { return &self; }
2423 class BumpTransactionEvent {
2425 LDKBumpTransactionEvent self;
2427 BumpTransactionEvent(const BumpTransactionEvent&) = delete;
2428 BumpTransactionEvent(BumpTransactionEvent&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEvent)); }
2429 BumpTransactionEvent(LDKBumpTransactionEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEvent)); }
2430 operator LDKBumpTransactionEvent() && { LDKBumpTransactionEvent res = self; memset(&self, 0, sizeof(LDKBumpTransactionEvent)); return res; }
2431 ~BumpTransactionEvent() { BumpTransactionEvent_free(self); }
2432 BumpTransactionEvent& operator=(BumpTransactionEvent&& o) { BumpTransactionEvent_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEvent)); return *this; }
2433 LDKBumpTransactionEvent* operator &() { return &self; }
2434 LDKBumpTransactionEvent* operator ->() { return &self; }
2435 const LDKBumpTransactionEvent* operator &() const { return &self; }
2436 const LDKBumpTransactionEvent* operator ->() const { return &self; }
2442 Input(const Input&) = delete;
2443 Input(Input&& o) : self(o.self) { memset(&o, 0, sizeof(Input)); }
2444 Input(LDKInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInput)); }
2445 operator LDKInput() && { LDKInput res = self; memset(&self, 0, sizeof(LDKInput)); return res; }
2446 ~Input() { Input_free(self); }
2447 Input& operator=(Input&& o) { Input_free(self); self = o.self; memset(&o, 0, sizeof(Input)); return *this; }
2448 LDKInput* operator &() { return &self; }
2449 LDKInput* operator ->() { return &self; }
2450 const LDKInput* operator &() const { return &self; }
2451 const LDKInput* operator ->() const { return &self; }
2457 Utxo(const Utxo&) = delete;
2458 Utxo(Utxo&& o) : self(o.self) { memset(&o, 0, sizeof(Utxo)); }
2459 Utxo(LDKUtxo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxo)); }
2460 operator LDKUtxo() && { LDKUtxo res = self; memset(&self, 0, sizeof(LDKUtxo)); return res; }
2461 ~Utxo() { Utxo_free(self); }
2462 Utxo& operator=(Utxo&& o) { Utxo_free(self); self = o.self; memset(&o, 0, sizeof(Utxo)); return *this; }
2463 LDKUtxo* operator &() { return &self; }
2464 LDKUtxo* operator ->() { return &self; }
2465 const LDKUtxo* operator &() const { return &self; }
2466 const LDKUtxo* operator ->() const { return &self; }
2468 class CoinSelection {
2470 LDKCoinSelection self;
2472 CoinSelection(const CoinSelection&) = delete;
2473 CoinSelection(CoinSelection&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelection)); }
2474 CoinSelection(LDKCoinSelection&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelection)); }
2475 operator LDKCoinSelection() && { LDKCoinSelection res = self; memset(&self, 0, sizeof(LDKCoinSelection)); return res; }
2476 ~CoinSelection() { CoinSelection_free(self); }
2477 CoinSelection& operator=(CoinSelection&& o) { CoinSelection_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelection)); return *this; }
2478 LDKCoinSelection* operator &() { return &self; }
2479 LDKCoinSelection* operator ->() { return &self; }
2480 const LDKCoinSelection* operator &() const { return &self; }
2481 const LDKCoinSelection* operator ->() const { return &self; }
2483 class CoinSelectionSource {
2485 LDKCoinSelectionSource self;
2487 CoinSelectionSource(const CoinSelectionSource&) = delete;
2488 CoinSelectionSource(CoinSelectionSource&& o) : self(o.self) { memset(&o, 0, sizeof(CoinSelectionSource)); }
2489 CoinSelectionSource(LDKCoinSelectionSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCoinSelectionSource)); }
2490 operator LDKCoinSelectionSource() && { LDKCoinSelectionSource res = self; memset(&self, 0, sizeof(LDKCoinSelectionSource)); return res; }
2491 ~CoinSelectionSource() { CoinSelectionSource_free(self); }
2492 CoinSelectionSource& operator=(CoinSelectionSource&& o) { CoinSelectionSource_free(self); self = o.self; memset(&o, 0, sizeof(CoinSelectionSource)); return *this; }
2493 LDKCoinSelectionSource* operator &() { return &self; }
2494 LDKCoinSelectionSource* operator ->() { return &self; }
2495 const LDKCoinSelectionSource* operator &() const { return &self; }
2496 const LDKCoinSelectionSource* operator ->() const { return &self; }
2498 * Performs coin selection of a set of UTXOs, with at least 1 confirmation each, that are
2499 * available to spend. Implementations are free to pick their coin selection algorithm of
2500 * choice, as long as the following requirements are met:
2502 * 1. `must_spend` contains a set of [`Input`]s that must be included in the transaction
2503 * throughout coin selection, but must not be returned as part of the result.
2504 * 2. `must_pay_to` contains a set of [`TxOut`]s that must be included in the transaction
2505 * throughout coin selection. In some cases, like when funding an anchor transaction, this
2506 * set is empty. Implementations should ensure they handle this correctly on their end,
2507 * e.g., Bitcoin Core's `fundrawtransaction` RPC requires at least one output to be
2508 * provided, in which case a zero-value empty OP_RETURN output can be used instead.
2509 * 3. Enough inputs must be selected/contributed for the resulting transaction (including the
2510 * inputs and outputs noted above) to meet `target_feerate_sat_per_1000_weight`.
2512 * Implementations must take note that [`Input::satisfaction_weight`] only tracks the weight of
2513 * the input's `script_sig` and `witness`. Some wallets, like Bitcoin Core's, may require
2514 * providing the full input weight. Failing to do so may lead to underestimating fee bumps and
2515 * delaying block inclusion.
2517 * The `claim_id` must map to the set of external UTXOs assigned to the claim, such that they
2518 * can be re-used within new fee-bumped iterations of the original claiming transaction,
2519 * ensuring that claims don't double spend each other. If a specific `claim_id` has never had a
2520 * transaction associated with it, and all of the available UTXOs have already been assigned to
2521 * other claims, implementations must be willing to double spend their UTXOs. The choice of
2522 * which UTXOs to double spend is left to the implementation, but it must strive to keep the
2523 * set of other claims being double spent to a minimum.
2525 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);
2527 * Signs and provides the full witness for all inputs within the transaction known to the
2528 * trait (i.e., any provided via [`CoinSelectionSource::select_confirmed_utxos`]).
2530 * If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
2531 * unsigned transaction and then sign it with your wallet.
2533 inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
2535 class WalletSource {
2537 LDKWalletSource self;
2539 WalletSource(const WalletSource&) = delete;
2540 WalletSource(WalletSource&& o) : self(o.self) { memset(&o, 0, sizeof(WalletSource)); }
2541 WalletSource(LDKWalletSource&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWalletSource)); }
2542 operator LDKWalletSource() && { LDKWalletSource res = self; memset(&self, 0, sizeof(LDKWalletSource)); return res; }
2543 ~WalletSource() { WalletSource_free(self); }
2544 WalletSource& operator=(WalletSource&& o) { WalletSource_free(self); self = o.self; memset(&o, 0, sizeof(WalletSource)); return *this; }
2545 LDKWalletSource* operator &() { return &self; }
2546 LDKWalletSource* operator ->() { return &self; }
2547 const LDKWalletSource* operator &() const { return &self; }
2548 const LDKWalletSource* operator ->() const { return &self; }
2550 * Returns all UTXOs, with at least 1 confirmation each, that are available to spend.
2552 inline LDK::CResult_CVec_UtxoZNoneZ list_confirmed_utxos();
2554 * Returns a script to use for change above dust resulting from a successful coin selection
2557 inline LDK::CResult_CVec_u8ZNoneZ get_change_script();
2559 * Signs and provides the full [`TxIn::script_sig`] and [`TxIn::witness`] for all inputs within
2560 * the transaction known to the wallet (i.e., any provided via
2561 * [`WalletSource::list_confirmed_utxos`]).
2563 * If your wallet does not support signing PSBTs you can call `psbt.extract_tx()` to get the
2564 * unsigned transaction and then sign it with your wallet.
2566 inline LDK::CResult_TransactionNoneZ sign_psbt(struct LDKCVec_u8Z psbt);
2572 Wallet(const Wallet&) = delete;
2573 Wallet(Wallet&& o) : self(o.self) { memset(&o, 0, sizeof(Wallet)); }
2574 Wallet(LDKWallet&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWallet)); }
2575 operator LDKWallet() && { LDKWallet res = self; memset(&self, 0, sizeof(LDKWallet)); return res; }
2576 ~Wallet() { Wallet_free(self); }
2577 Wallet& operator=(Wallet&& o) { Wallet_free(self); self = o.self; memset(&o, 0, sizeof(Wallet)); return *this; }
2578 LDKWallet* operator &() { return &self; }
2579 LDKWallet* operator ->() { return &self; }
2580 const LDKWallet* operator &() const { return &self; }
2581 const LDKWallet* operator ->() const { return &self; }
2583 class BumpTransactionEventHandler {
2585 LDKBumpTransactionEventHandler self;
2587 BumpTransactionEventHandler(const BumpTransactionEventHandler&) = delete;
2588 BumpTransactionEventHandler(BumpTransactionEventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(BumpTransactionEventHandler)); }
2589 BumpTransactionEventHandler(LDKBumpTransactionEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBumpTransactionEventHandler)); }
2590 operator LDKBumpTransactionEventHandler() && { LDKBumpTransactionEventHandler res = self; memset(&self, 0, sizeof(LDKBumpTransactionEventHandler)); return res; }
2591 ~BumpTransactionEventHandler() { BumpTransactionEventHandler_free(self); }
2592 BumpTransactionEventHandler& operator=(BumpTransactionEventHandler&& o) { BumpTransactionEventHandler_free(self); self = o.self; memset(&o, 0, sizeof(BumpTransactionEventHandler)); return *this; }
2593 LDKBumpTransactionEventHandler* operator &() { return &self; }
2594 LDKBumpTransactionEventHandler* operator ->() { return &self; }
2595 const LDKBumpTransactionEventHandler* operator &() const { return &self; }
2596 const LDKBumpTransactionEventHandler* operator ->() const { return &self; }
2598 class PendingHTLCRouting {
2600 LDKPendingHTLCRouting self;
2602 PendingHTLCRouting(const PendingHTLCRouting&) = delete;
2603 PendingHTLCRouting(PendingHTLCRouting&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCRouting)); }
2604 PendingHTLCRouting(LDKPendingHTLCRouting&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCRouting)); }
2605 operator LDKPendingHTLCRouting() && { LDKPendingHTLCRouting res = self; memset(&self, 0, sizeof(LDKPendingHTLCRouting)); return res; }
2606 ~PendingHTLCRouting() { PendingHTLCRouting_free(self); }
2607 PendingHTLCRouting& operator=(PendingHTLCRouting&& o) { PendingHTLCRouting_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCRouting)); return *this; }
2608 LDKPendingHTLCRouting* operator &() { return &self; }
2609 LDKPendingHTLCRouting* operator ->() { return &self; }
2610 const LDKPendingHTLCRouting* operator &() const { return &self; }
2611 const LDKPendingHTLCRouting* operator ->() const { return &self; }
2613 class BlindedForward {
2615 LDKBlindedForward self;
2617 BlindedForward(const BlindedForward&) = delete;
2618 BlindedForward(BlindedForward&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedForward)); }
2619 BlindedForward(LDKBlindedForward&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedForward)); }
2620 operator LDKBlindedForward() && { LDKBlindedForward res = self; memset(&self, 0, sizeof(LDKBlindedForward)); return res; }
2621 ~BlindedForward() { BlindedForward_free(self); }
2622 BlindedForward& operator=(BlindedForward&& o) { BlindedForward_free(self); self = o.self; memset(&o, 0, sizeof(BlindedForward)); return *this; }
2623 LDKBlindedForward* operator &() { return &self; }
2624 LDKBlindedForward* operator ->() { return &self; }
2625 const LDKBlindedForward* operator &() const { return &self; }
2626 const LDKBlindedForward* operator ->() const { return &self; }
2628 class PendingHTLCInfo {
2630 LDKPendingHTLCInfo self;
2632 PendingHTLCInfo(const PendingHTLCInfo&) = delete;
2633 PendingHTLCInfo(PendingHTLCInfo&& o) : self(o.self) { memset(&o, 0, sizeof(PendingHTLCInfo)); }
2634 PendingHTLCInfo(LDKPendingHTLCInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPendingHTLCInfo)); }
2635 operator LDKPendingHTLCInfo() && { LDKPendingHTLCInfo res = self; memset(&self, 0, sizeof(LDKPendingHTLCInfo)); return res; }
2636 ~PendingHTLCInfo() { PendingHTLCInfo_free(self); }
2637 PendingHTLCInfo& operator=(PendingHTLCInfo&& o) { PendingHTLCInfo_free(self); self = o.self; memset(&o, 0, sizeof(PendingHTLCInfo)); return *this; }
2638 LDKPendingHTLCInfo* operator &() { return &self; }
2639 LDKPendingHTLCInfo* operator ->() { return &self; }
2640 const LDKPendingHTLCInfo* operator &() const { return &self; }
2641 const LDKPendingHTLCInfo* operator ->() const { return &self; }
2643 class BlindedFailure {
2645 LDKBlindedFailure self;
2647 BlindedFailure(const BlindedFailure&) = delete;
2648 BlindedFailure(BlindedFailure&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedFailure)); }
2649 BlindedFailure(LDKBlindedFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedFailure)); }
2650 operator LDKBlindedFailure() && { LDKBlindedFailure res = self; memset(&self, 0, sizeof(LDKBlindedFailure)); return res; }
2651 BlindedFailure& operator=(BlindedFailure&& o) { self = o.self; memset(&o, 0, sizeof(BlindedFailure)); return *this; }
2652 LDKBlindedFailure* operator &() { return &self; }
2653 LDKBlindedFailure* operator ->() { return &self; }
2654 const LDKBlindedFailure* operator &() const { return &self; }
2655 const LDKBlindedFailure* operator ->() const { return &self; }
2659 LDKFailureCode self;
2661 FailureCode(const FailureCode&) = delete;
2662 FailureCode(FailureCode&& o) : self(o.self) { memset(&o, 0, sizeof(FailureCode)); }
2663 FailureCode(LDKFailureCode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFailureCode)); }
2664 operator LDKFailureCode() && { LDKFailureCode res = self; memset(&self, 0, sizeof(LDKFailureCode)); return res; }
2665 ~FailureCode() { FailureCode_free(self); }
2666 FailureCode& operator=(FailureCode&& o) { FailureCode_free(self); self = o.self; memset(&o, 0, sizeof(FailureCode)); return *this; }
2667 LDKFailureCode* operator &() { return &self; }
2668 LDKFailureCode* operator ->() { return &self; }
2669 const LDKFailureCode* operator &() const { return &self; }
2670 const LDKFailureCode* operator ->() const { return &self; }
2672 class ChannelManager {
2674 LDKChannelManager self;
2676 ChannelManager(const ChannelManager&) = delete;
2677 ChannelManager(ChannelManager&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManager)); }
2678 ChannelManager(LDKChannelManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManager)); }
2679 operator LDKChannelManager() && { LDKChannelManager res = self; memset(&self, 0, sizeof(LDKChannelManager)); return res; }
2680 ~ChannelManager() { ChannelManager_free(self); }
2681 ChannelManager& operator=(ChannelManager&& o) { ChannelManager_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManager)); return *this; }
2682 LDKChannelManager* operator &() { return &self; }
2683 LDKChannelManager* operator ->() { return &self; }
2684 const LDKChannelManager* operator &() const { return &self; }
2685 const LDKChannelManager* operator ->() const { return &self; }
2687 class ChainParameters {
2689 LDKChainParameters self;
2691 ChainParameters(const ChainParameters&) = delete;
2692 ChainParameters(ChainParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChainParameters)); }
2693 ChainParameters(LDKChainParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainParameters)); }
2694 operator LDKChainParameters() && { LDKChainParameters res = self; memset(&self, 0, sizeof(LDKChainParameters)); return res; }
2695 ~ChainParameters() { ChainParameters_free(self); }
2696 ChainParameters& operator=(ChainParameters&& o) { ChainParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChainParameters)); return *this; }
2697 LDKChainParameters* operator &() { return &self; }
2698 LDKChainParameters* operator ->() { return &self; }
2699 const LDKChainParameters* operator &() const { return &self; }
2700 const LDKChainParameters* operator ->() const { return &self; }
2702 class CounterpartyForwardingInfo {
2704 LDKCounterpartyForwardingInfo self;
2706 CounterpartyForwardingInfo(const CounterpartyForwardingInfo&) = delete;
2707 CounterpartyForwardingInfo(CounterpartyForwardingInfo&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyForwardingInfo)); }
2708 CounterpartyForwardingInfo(LDKCounterpartyForwardingInfo&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyForwardingInfo)); }
2709 operator LDKCounterpartyForwardingInfo() && { LDKCounterpartyForwardingInfo res = self; memset(&self, 0, sizeof(LDKCounterpartyForwardingInfo)); return res; }
2710 ~CounterpartyForwardingInfo() { CounterpartyForwardingInfo_free(self); }
2711 CounterpartyForwardingInfo& operator=(CounterpartyForwardingInfo&& o) { CounterpartyForwardingInfo_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyForwardingInfo)); return *this; }
2712 LDKCounterpartyForwardingInfo* operator &() { return &self; }
2713 LDKCounterpartyForwardingInfo* operator ->() { return &self; }
2714 const LDKCounterpartyForwardingInfo* operator &() const { return &self; }
2715 const LDKCounterpartyForwardingInfo* operator ->() const { return &self; }
2717 class ChannelCounterparty {
2719 LDKChannelCounterparty self;
2721 ChannelCounterparty(const ChannelCounterparty&) = delete;
2722 ChannelCounterparty(ChannelCounterparty&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelCounterparty)); }
2723 ChannelCounterparty(LDKChannelCounterparty&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelCounterparty)); }
2724 operator LDKChannelCounterparty() && { LDKChannelCounterparty res = self; memset(&self, 0, sizeof(LDKChannelCounterparty)); return res; }
2725 ~ChannelCounterparty() { ChannelCounterparty_free(self); }
2726 ChannelCounterparty& operator=(ChannelCounterparty&& o) { ChannelCounterparty_free(self); self = o.self; memset(&o, 0, sizeof(ChannelCounterparty)); return *this; }
2727 LDKChannelCounterparty* operator &() { return &self; }
2728 LDKChannelCounterparty* operator ->() { return &self; }
2729 const LDKChannelCounterparty* operator &() const { return &self; }
2730 const LDKChannelCounterparty* operator ->() const { return &self; }
2732 class ChannelDetails {
2734 LDKChannelDetails self;
2736 ChannelDetails(const ChannelDetails&) = delete;
2737 ChannelDetails(ChannelDetails&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelDetails)); }
2738 ChannelDetails(LDKChannelDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelDetails)); }
2739 operator LDKChannelDetails() && { LDKChannelDetails res = self; memset(&self, 0, sizeof(LDKChannelDetails)); return res; }
2740 ~ChannelDetails() { ChannelDetails_free(self); }
2741 ChannelDetails& operator=(ChannelDetails&& o) { ChannelDetails_free(self); self = o.self; memset(&o, 0, sizeof(ChannelDetails)); return *this; }
2742 LDKChannelDetails* operator &() { return &self; }
2743 LDKChannelDetails* operator ->() { return &self; }
2744 const LDKChannelDetails* operator &() const { return &self; }
2745 const LDKChannelDetails* operator ->() const { return &self; }
2747 class ChannelShutdownState {
2749 LDKChannelShutdownState self;
2751 ChannelShutdownState(const ChannelShutdownState&) = delete;
2752 ChannelShutdownState(ChannelShutdownState&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelShutdownState)); }
2753 ChannelShutdownState(LDKChannelShutdownState&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelShutdownState)); }
2754 operator LDKChannelShutdownState() && { LDKChannelShutdownState res = self; memset(&self, 0, sizeof(LDKChannelShutdownState)); return res; }
2755 ChannelShutdownState& operator=(ChannelShutdownState&& o) { self = o.self; memset(&o, 0, sizeof(ChannelShutdownState)); return *this; }
2756 LDKChannelShutdownState* operator &() { return &self; }
2757 LDKChannelShutdownState* operator ->() { return &self; }
2758 const LDKChannelShutdownState* operator &() const { return &self; }
2759 const LDKChannelShutdownState* operator ->() const { return &self; }
2761 class RecentPaymentDetails {
2763 LDKRecentPaymentDetails self;
2765 RecentPaymentDetails(const RecentPaymentDetails&) = delete;
2766 RecentPaymentDetails(RecentPaymentDetails&& o) : self(o.self) { memset(&o, 0, sizeof(RecentPaymentDetails)); }
2767 RecentPaymentDetails(LDKRecentPaymentDetails&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecentPaymentDetails)); }
2768 operator LDKRecentPaymentDetails() && { LDKRecentPaymentDetails res = self; memset(&self, 0, sizeof(LDKRecentPaymentDetails)); return res; }
2769 ~RecentPaymentDetails() { RecentPaymentDetails_free(self); }
2770 RecentPaymentDetails& operator=(RecentPaymentDetails&& o) { RecentPaymentDetails_free(self); self = o.self; memset(&o, 0, sizeof(RecentPaymentDetails)); return *this; }
2771 LDKRecentPaymentDetails* operator &() { return &self; }
2772 LDKRecentPaymentDetails* operator ->() { return &self; }
2773 const LDKRecentPaymentDetails* operator &() const { return &self; }
2774 const LDKRecentPaymentDetails* operator ->() const { return &self; }
2776 class PhantomRouteHints {
2778 LDKPhantomRouteHints self;
2780 PhantomRouteHints(const PhantomRouteHints&) = delete;
2781 PhantomRouteHints(PhantomRouteHints&& o) : self(o.self) { memset(&o, 0, sizeof(PhantomRouteHints)); }
2782 PhantomRouteHints(LDKPhantomRouteHints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPhantomRouteHints)); }
2783 operator LDKPhantomRouteHints() && { LDKPhantomRouteHints res = self; memset(&self, 0, sizeof(LDKPhantomRouteHints)); return res; }
2784 ~PhantomRouteHints() { PhantomRouteHints_free(self); }
2785 PhantomRouteHints& operator=(PhantomRouteHints&& o) { PhantomRouteHints_free(self); self = o.self; memset(&o, 0, sizeof(PhantomRouteHints)); return *this; }
2786 LDKPhantomRouteHints* operator &() { return &self; }
2787 LDKPhantomRouteHints* operator ->() { return &self; }
2788 const LDKPhantomRouteHints* operator &() const { return &self; }
2789 const LDKPhantomRouteHints* operator ->() const { return &self; }
2791 class ChannelManagerReadArgs {
2793 LDKChannelManagerReadArgs self;
2795 ChannelManagerReadArgs(const ChannelManagerReadArgs&) = delete;
2796 ChannelManagerReadArgs(ChannelManagerReadArgs&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelManagerReadArgs)); }
2797 ChannelManagerReadArgs(LDKChannelManagerReadArgs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelManagerReadArgs)); }
2798 operator LDKChannelManagerReadArgs() && { LDKChannelManagerReadArgs res = self; memset(&self, 0, sizeof(LDKChannelManagerReadArgs)); return res; }
2799 ~ChannelManagerReadArgs() { ChannelManagerReadArgs_free(self); }
2800 ChannelManagerReadArgs& operator=(ChannelManagerReadArgs&& o) { ChannelManagerReadArgs_free(self); self = o.self; memset(&o, 0, sizeof(ChannelManagerReadArgs)); return *this; }
2801 LDKChannelManagerReadArgs* operator &() { return &self; }
2802 LDKChannelManagerReadArgs* operator ->() { return &self; }
2803 const LDKChannelManagerReadArgs* operator &() const { return &self; }
2804 const LDKChannelManagerReadArgs* operator ->() const { return &self; }
2806 class ChannelHandshakeConfig {
2808 LDKChannelHandshakeConfig self;
2810 ChannelHandshakeConfig(const ChannelHandshakeConfig&) = delete;
2811 ChannelHandshakeConfig(ChannelHandshakeConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeConfig)); }
2812 ChannelHandshakeConfig(LDKChannelHandshakeConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeConfig)); }
2813 operator LDKChannelHandshakeConfig() && { LDKChannelHandshakeConfig res = self; memset(&self, 0, sizeof(LDKChannelHandshakeConfig)); return res; }
2814 ~ChannelHandshakeConfig() { ChannelHandshakeConfig_free(self); }
2815 ChannelHandshakeConfig& operator=(ChannelHandshakeConfig&& o) { ChannelHandshakeConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeConfig)); return *this; }
2816 LDKChannelHandshakeConfig* operator &() { return &self; }
2817 LDKChannelHandshakeConfig* operator ->() { return &self; }
2818 const LDKChannelHandshakeConfig* operator &() const { return &self; }
2819 const LDKChannelHandshakeConfig* operator ->() const { return &self; }
2821 class ChannelHandshakeLimits {
2823 LDKChannelHandshakeLimits self;
2825 ChannelHandshakeLimits(const ChannelHandshakeLimits&) = delete;
2826 ChannelHandshakeLimits(ChannelHandshakeLimits&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelHandshakeLimits)); }
2827 ChannelHandshakeLimits(LDKChannelHandshakeLimits&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelHandshakeLimits)); }
2828 operator LDKChannelHandshakeLimits() && { LDKChannelHandshakeLimits res = self; memset(&self, 0, sizeof(LDKChannelHandshakeLimits)); return res; }
2829 ~ChannelHandshakeLimits() { ChannelHandshakeLimits_free(self); }
2830 ChannelHandshakeLimits& operator=(ChannelHandshakeLimits&& o) { ChannelHandshakeLimits_free(self); self = o.self; memset(&o, 0, sizeof(ChannelHandshakeLimits)); return *this; }
2831 LDKChannelHandshakeLimits* operator &() { return &self; }
2832 LDKChannelHandshakeLimits* operator ->() { return &self; }
2833 const LDKChannelHandshakeLimits* operator &() const { return &self; }
2834 const LDKChannelHandshakeLimits* operator ->() const { return &self; }
2836 class MaxDustHTLCExposure {
2838 LDKMaxDustHTLCExposure self;
2840 MaxDustHTLCExposure(const MaxDustHTLCExposure&) = delete;
2841 MaxDustHTLCExposure(MaxDustHTLCExposure&& o) : self(o.self) { memset(&o, 0, sizeof(MaxDustHTLCExposure)); }
2842 MaxDustHTLCExposure(LDKMaxDustHTLCExposure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMaxDustHTLCExposure)); }
2843 operator LDKMaxDustHTLCExposure() && { LDKMaxDustHTLCExposure res = self; memset(&self, 0, sizeof(LDKMaxDustHTLCExposure)); return res; }
2844 ~MaxDustHTLCExposure() { MaxDustHTLCExposure_free(self); }
2845 MaxDustHTLCExposure& operator=(MaxDustHTLCExposure&& o) { MaxDustHTLCExposure_free(self); self = o.self; memset(&o, 0, sizeof(MaxDustHTLCExposure)); return *this; }
2846 LDKMaxDustHTLCExposure* operator &() { return &self; }
2847 LDKMaxDustHTLCExposure* operator ->() { return &self; }
2848 const LDKMaxDustHTLCExposure* operator &() const { return &self; }
2849 const LDKMaxDustHTLCExposure* operator ->() const { return &self; }
2851 class ChannelConfig {
2853 LDKChannelConfig self;
2855 ChannelConfig(const ChannelConfig&) = delete;
2856 ChannelConfig(ChannelConfig&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfig)); }
2857 ChannelConfig(LDKChannelConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfig)); }
2858 operator LDKChannelConfig() && { LDKChannelConfig res = self; memset(&self, 0, sizeof(LDKChannelConfig)); return res; }
2859 ~ChannelConfig() { ChannelConfig_free(self); }
2860 ChannelConfig& operator=(ChannelConfig&& o) { ChannelConfig_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfig)); return *this; }
2861 LDKChannelConfig* operator &() { return &self; }
2862 LDKChannelConfig* operator ->() { return &self; }
2863 const LDKChannelConfig* operator &() const { return &self; }
2864 const LDKChannelConfig* operator ->() const { return &self; }
2866 class ChannelConfigUpdate {
2868 LDKChannelConfigUpdate self;
2870 ChannelConfigUpdate(const ChannelConfigUpdate&) = delete;
2871 ChannelConfigUpdate(ChannelConfigUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelConfigUpdate)); }
2872 ChannelConfigUpdate(LDKChannelConfigUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelConfigUpdate)); }
2873 operator LDKChannelConfigUpdate() && { LDKChannelConfigUpdate res = self; memset(&self, 0, sizeof(LDKChannelConfigUpdate)); return res; }
2874 ~ChannelConfigUpdate() { ChannelConfigUpdate_free(self); }
2875 ChannelConfigUpdate& operator=(ChannelConfigUpdate&& o) { ChannelConfigUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelConfigUpdate)); return *this; }
2876 LDKChannelConfigUpdate* operator &() { return &self; }
2877 LDKChannelConfigUpdate* operator ->() { return &self; }
2878 const LDKChannelConfigUpdate* operator &() const { return &self; }
2879 const LDKChannelConfigUpdate* operator ->() const { return &self; }
2885 UserConfig(const UserConfig&) = delete;
2886 UserConfig(UserConfig&& o) : self(o.self) { memset(&o, 0, sizeof(UserConfig)); }
2887 UserConfig(LDKUserConfig&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUserConfig)); }
2888 operator LDKUserConfig() && { LDKUserConfig res = self; memset(&self, 0, sizeof(LDKUserConfig)); return res; }
2889 ~UserConfig() { UserConfig_free(self); }
2890 UserConfig& operator=(UserConfig&& o) { UserConfig_free(self); self = o.self; memset(&o, 0, sizeof(UserConfig)); return *this; }
2891 LDKUserConfig* operator &() { return &self; }
2892 LDKUserConfig* operator ->() { return &self; }
2893 const LDKUserConfig* operator &() const { return &self; }
2894 const LDKUserConfig* operator ->() const { return &self; }
2900 APIError(const APIError&) = delete;
2901 APIError(APIError&& o) : self(o.self) { memset(&o, 0, sizeof(APIError)); }
2902 APIError(LDKAPIError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAPIError)); }
2903 operator LDKAPIError() && { LDKAPIError res = self; memset(&self, 0, sizeof(LDKAPIError)); return res; }
2904 ~APIError() { APIError_free(self); }
2905 APIError& operator=(APIError&& o) { APIError_free(self); self = o.self; memset(&o, 0, sizeof(APIError)); return *this; }
2906 LDKAPIError* operator &() { return &self; }
2907 LDKAPIError* operator ->() { return &self; }
2908 const LDKAPIError* operator &() const { return &self; }
2909 const LDKAPIError* operator ->() const { return &self; }
2915 TaggedHash(const TaggedHash&) = delete;
2916 TaggedHash(TaggedHash&& o) : self(o.self) { memset(&o, 0, sizeof(TaggedHash)); }
2917 TaggedHash(LDKTaggedHash&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTaggedHash)); }
2918 operator LDKTaggedHash() && { LDKTaggedHash res = self; memset(&self, 0, sizeof(LDKTaggedHash)); return res; }
2919 ~TaggedHash() { TaggedHash_free(self); }
2920 TaggedHash& operator=(TaggedHash&& o) { TaggedHash_free(self); self = o.self; memset(&o, 0, sizeof(TaggedHash)); return *this; }
2921 LDKTaggedHash* operator &() { return &self; }
2922 LDKTaggedHash* operator ->() { return &self; }
2923 const LDKTaggedHash* operator &() const { return &self; }
2924 const LDKTaggedHash* operator ->() const { return &self; }
2926 class EcdsaChannelSigner {
2928 LDKEcdsaChannelSigner self;
2930 EcdsaChannelSigner(const EcdsaChannelSigner&) = delete;
2931 EcdsaChannelSigner(EcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(EcdsaChannelSigner)); }
2932 EcdsaChannelSigner(LDKEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEcdsaChannelSigner)); }
2933 operator LDKEcdsaChannelSigner() && { LDKEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKEcdsaChannelSigner)); return res; }
2934 ~EcdsaChannelSigner() { EcdsaChannelSigner_free(self); }
2935 EcdsaChannelSigner& operator=(EcdsaChannelSigner&& o) { EcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(EcdsaChannelSigner)); return *this; }
2936 LDKEcdsaChannelSigner* operator &() { return &self; }
2937 LDKEcdsaChannelSigner* operator ->() { return &self; }
2938 const LDKEcdsaChannelSigner* operator &() const { return &self; }
2939 const LDKEcdsaChannelSigner* operator ->() const { return &self; }
2941 * Create a signature for a counterparty's commitment transaction and associated HTLC transactions.
2943 * Note that if signing fails or is rejected, the channel will be force-closed.
2945 * Policy checks should be implemented in this function, including checking the amount
2946 * sent to us and checking the HTLCs.
2948 * The preimages of outbound and inbound HTLCs that were fulfilled since the last commitment
2949 * are provided. A validating signer should ensure that an outbound HTLC output is removed
2950 * only when the matching preimage is provided and after the corresponding inbound HTLC has
2951 * been removed for forwarded payments.
2953 * Note that all the relevant preimages will be provided, but there may also be additional
2954 * irrelevant or duplicate preimages.
2956 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages);
2958 * Creates a signature for a holder's commitment transaction.
2960 * This will be called
2961 * - with a non-revoked `commitment_tx`.
2962 * - with the latest `commitment_tx` when we initiate a force-close.
2964 * This may be called multiple times for the same transaction.
2966 * An external signer implementation should check that the commitment has not been revoked.
2968 inline LDK::CResult_ECDSASignatureNoneZ sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx);
2970 * Create a signature for the given input in a transaction spending an HTLC transaction output
2971 * or a commitment transaction `to_local` output when our counterparty broadcasts an old state.
2973 * A justice transaction may claim multiple outputs at the same time if timelocks are
2974 * similar, but only a signature for the input at index `input` should be signed for here.
2975 * It may be called multiple times for same output(s) if a fee-bump is needed with regards
2976 * to an upcoming timelock expiration.
2978 * Amount is value of the output spent by this input, committed to in the BIP 143 signature.
2980 * `per_commitment_key` is revocation secret which was provided by our counterparty when they
2981 * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
2982 * not allow the spending of any funds by itself (you need our holder `revocation_secret` to do
2985 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]);
2987 * Create a signature for the given input in a transaction spending a commitment transaction
2988 * HTLC output when our counterparty broadcasts an old state.
2990 * A justice transaction may claim multiple outputs at the same time if timelocks are
2991 * similar, but only a signature for the input at index `input` should be signed for here.
2992 * It may be called multiple times for same output(s) if a fee-bump is needed with regards
2993 * to an upcoming timelock expiration.
2995 * `amount` is the value of the output spent by this input, committed to in the BIP 143
2998 * `per_commitment_key` is revocation secret which was provided by our counterparty when they
2999 * revoked the state which they eventually broadcast. It's not a _holder_ secret key and does
3000 * not allow the spending of any funds by itself (you need our holder revocation_secret to do
3003 * `htlc` holds HTLC elements (hash, timelock), thus changing the format of the witness script
3004 * (which is committed to in the BIP 143 signatures).
3006 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);
3008 * Computes the signature for a commitment transaction's HTLC output used as an input within
3009 * `htlc_tx`, which spends the commitment transaction at index `input`. The signature returned
3010 * must be be computed using [`EcdsaSighashType::All`].
3012 * Note that this may be called for HTLCs in the penultimate commitment transaction if a
3013 * [`ChannelMonitor`] [replica](https://github.com/lightningdevkit/rust-lightning/blob/main/GLOSSARY.md#monitor-replicas)
3014 * broadcasts it before receiving the update for the latest commitment transaction.
3016 * [`EcdsaSighashType::All`]: bitcoin::sighash::EcdsaSighashType::All
3017 * [`ChannelMonitor`]: crate::chain::channelmonitor::ChannelMonitor
3019 inline LDK::CResult_ECDSASignatureNoneZ sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor);
3021 * Create a signature for a claiming transaction for a HTLC output on a counterparty's commitment
3022 * transaction, either offered or received.
3024 * Such a transaction may claim multiples offered outputs at same time if we know the
3025 * preimage for each when we create it, but only the input at index `input` should be
3026 * signed for here. It may be called multiple times for same output(s) if a fee-bump is
3027 * needed with regards to an upcoming timelock expiration.
3029 * `witness_script` is either an offered or received script as defined in BOLT3 for HTLC
3032 * `amount` is value of the output spent by this input, committed to in the BIP 143 signature.
3034 * `per_commitment_point` is the dynamic point corresponding to the channel state
3035 * detected onchain. It has been generated by our counterparty and is used to derive
3036 * channel state keys, which are then included in the witness script and committed to in the
3037 * BIP 143 signature.
3039 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);
3041 * Create a signature for a (proposed) closing transaction.
3043 * Note that, due to rounding, there may be one "missing" satoshi, and either party may have
3044 * chosen to forgo their output as dust.
3046 inline LDK::CResult_ECDSASignatureNoneZ sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx);
3048 * Computes the signature for a commitment transaction's anchor output used as an
3049 * input within `anchor_tx`, which spends the commitment transaction, at index `input`.
3051 inline LDK::CResult_ECDSASignatureNoneZ sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input);
3053 * Signs a channel announcement message with our funding key proving it comes from one of the
3054 * channel participants.
3056 * Channel announcements also require a signature from each node's network key. Our node
3057 * signature is computed through [`NodeSigner::sign_gossip_message`].
3059 * Note that if this fails or is rejected, the channel will not be publicly announced and
3060 * our counterparty may (though likely will not) close the channel on us for violating the
3063 * [`NodeSigner::sign_gossip_message`]: crate::sign::NodeSigner::sign_gossip_message
3065 inline LDK::CResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg);
3067 class WriteableEcdsaChannelSigner {
3069 LDKWriteableEcdsaChannelSigner self;
3071 WriteableEcdsaChannelSigner(const WriteableEcdsaChannelSigner&) = delete;
3072 WriteableEcdsaChannelSigner(WriteableEcdsaChannelSigner&& o) : self(o.self) { memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); }
3073 WriteableEcdsaChannelSigner(LDKWriteableEcdsaChannelSigner&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); }
3074 operator LDKWriteableEcdsaChannelSigner() && { LDKWriteableEcdsaChannelSigner res = self; memset(&self, 0, sizeof(LDKWriteableEcdsaChannelSigner)); return res; }
3075 ~WriteableEcdsaChannelSigner() { WriteableEcdsaChannelSigner_free(self); }
3076 WriteableEcdsaChannelSigner& operator=(WriteableEcdsaChannelSigner&& o) { WriteableEcdsaChannelSigner_free(self); self = o.self; memset(&o, 0, sizeof(WriteableEcdsaChannelSigner)); return *this; }
3077 LDKWriteableEcdsaChannelSigner* operator &() { return &self; }
3078 LDKWriteableEcdsaChannelSigner* operator ->() { return &self; }
3079 const LDKWriteableEcdsaChannelSigner* operator &() const { return &self; }
3080 const LDKWriteableEcdsaChannelSigner* operator ->() const { return &self; }
3082 class ChannelMonitorUpdate {
3084 LDKChannelMonitorUpdate self;
3086 ChannelMonitorUpdate(const ChannelMonitorUpdate&) = delete;
3087 ChannelMonitorUpdate(ChannelMonitorUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitorUpdate)); }
3088 ChannelMonitorUpdate(LDKChannelMonitorUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitorUpdate)); }
3089 operator LDKChannelMonitorUpdate() && { LDKChannelMonitorUpdate res = self; memset(&self, 0, sizeof(LDKChannelMonitorUpdate)); return res; }
3090 ~ChannelMonitorUpdate() { ChannelMonitorUpdate_free(self); }
3091 ChannelMonitorUpdate& operator=(ChannelMonitorUpdate&& o) { ChannelMonitorUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitorUpdate)); return *this; }
3092 LDKChannelMonitorUpdate* operator &() { return &self; }
3093 LDKChannelMonitorUpdate* operator ->() { return &self; }
3094 const LDKChannelMonitorUpdate* operator &() const { return &self; }
3095 const LDKChannelMonitorUpdate* operator ->() const { return &self; }
3097 class MonitorEvent {
3099 LDKMonitorEvent self;
3101 MonitorEvent(const MonitorEvent&) = delete;
3102 MonitorEvent(MonitorEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorEvent)); }
3103 MonitorEvent(LDKMonitorEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorEvent)); }
3104 operator LDKMonitorEvent() && { LDKMonitorEvent res = self; memset(&self, 0, sizeof(LDKMonitorEvent)); return res; }
3105 ~MonitorEvent() { MonitorEvent_free(self); }
3106 MonitorEvent& operator=(MonitorEvent&& o) { MonitorEvent_free(self); self = o.self; memset(&o, 0, sizeof(MonitorEvent)); return *this; }
3107 LDKMonitorEvent* operator &() { return &self; }
3108 LDKMonitorEvent* operator ->() { return &self; }
3109 const LDKMonitorEvent* operator &() const { return &self; }
3110 const LDKMonitorEvent* operator ->() const { return &self; }
3116 HTLCUpdate(const HTLCUpdate&) = delete;
3117 HTLCUpdate(HTLCUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCUpdate)); }
3118 HTLCUpdate(LDKHTLCUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCUpdate)); }
3119 operator LDKHTLCUpdate() && { LDKHTLCUpdate res = self; memset(&self, 0, sizeof(LDKHTLCUpdate)); return res; }
3120 ~HTLCUpdate() { HTLCUpdate_free(self); }
3121 HTLCUpdate& operator=(HTLCUpdate&& o) { HTLCUpdate_free(self); self = o.self; memset(&o, 0, sizeof(HTLCUpdate)); return *this; }
3122 LDKHTLCUpdate* operator &() { return &self; }
3123 LDKHTLCUpdate* operator ->() { return &self; }
3124 const LDKHTLCUpdate* operator &() const { return &self; }
3125 const LDKHTLCUpdate* operator ->() const { return &self; }
3131 Balance(const Balance&) = delete;
3132 Balance(Balance&& o) : self(o.self) { memset(&o, 0, sizeof(Balance)); }
3133 Balance(LDKBalance&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBalance)); }
3134 operator LDKBalance() && { LDKBalance res = self; memset(&self, 0, sizeof(LDKBalance)); return res; }
3135 ~Balance() { Balance_free(self); }
3136 Balance& operator=(Balance&& o) { Balance_free(self); self = o.self; memset(&o, 0, sizeof(Balance)); return *this; }
3137 LDKBalance* operator &() { return &self; }
3138 LDKBalance* operator ->() { return &self; }
3139 const LDKBalance* operator &() const { return &self; }
3140 const LDKBalance* operator ->() const { return &self; }
3142 class ChannelMonitor {
3144 LDKChannelMonitor self;
3146 ChannelMonitor(const ChannelMonitor&) = delete;
3147 ChannelMonitor(ChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMonitor)); }
3148 ChannelMonitor(LDKChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMonitor)); }
3149 operator LDKChannelMonitor() && { LDKChannelMonitor res = self; memset(&self, 0, sizeof(LDKChannelMonitor)); return res; }
3150 ~ChannelMonitor() { ChannelMonitor_free(self); }
3151 ChannelMonitor& operator=(ChannelMonitor&& o) { ChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMonitor)); return *this; }
3152 LDKChannelMonitor* operator &() { return &self; }
3153 LDKChannelMonitor* operator ->() { return &self; }
3154 const LDKChannelMonitor* operator &() const { return &self; }
3155 const LDKChannelMonitor* operator ->() const { return &self; }
3159 LDKExpandedKey self;
3161 ExpandedKey(const ExpandedKey&) = delete;
3162 ExpandedKey(ExpandedKey&& o) : self(o.self) { memset(&o, 0, sizeof(ExpandedKey)); }
3163 ExpandedKey(LDKExpandedKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpandedKey)); }
3164 operator LDKExpandedKey() && { LDKExpandedKey res = self; memset(&self, 0, sizeof(LDKExpandedKey)); return res; }
3165 ~ExpandedKey() { ExpandedKey_free(self); }
3166 ExpandedKey& operator=(ExpandedKey&& o) { ExpandedKey_free(self); self = o.self; memset(&o, 0, sizeof(ExpandedKey)); return *this; }
3167 LDKExpandedKey* operator &() { return &self; }
3168 LDKExpandedKey* operator ->() { return &self; }
3169 const LDKExpandedKey* operator &() const { return &self; }
3170 const LDKExpandedKey* operator ->() const { return &self; }
3172 class CustomMessageHandler {
3174 LDKCustomMessageHandler self;
3176 CustomMessageHandler(const CustomMessageHandler&) = delete;
3177 CustomMessageHandler(CustomMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageHandler)); }
3178 CustomMessageHandler(LDKCustomMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageHandler)); }
3179 operator LDKCustomMessageHandler() && { LDKCustomMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomMessageHandler)); return res; }
3180 ~CustomMessageHandler() { CustomMessageHandler_free(self); }
3181 CustomMessageHandler& operator=(CustomMessageHandler&& o) { CustomMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageHandler)); return *this; }
3182 LDKCustomMessageHandler* operator &() { return &self; }
3183 LDKCustomMessageHandler* operator ->() { return &self; }
3184 const LDKCustomMessageHandler* operator &() const { return &self; }
3185 const LDKCustomMessageHandler* operator ->() const { return &self; }
3187 * Handles the given message sent from `sender_node_id`, possibly producing messages for
3188 * [`CustomMessageHandler::get_and_clear_pending_msg`] to return and thus for [`PeerManager`]
3191 inline LDK::CResult_NoneLightningErrorZ handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id);
3193 * Returns the list of pending messages that were generated by the handler, clearing the list
3194 * in the process. Each message is paired with the node id of the intended recipient. If no
3195 * connection to the node exists, then the message is simply not sent.
3197 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg();
3199 * Gets the node feature flags which this handler itself supports. All available handlers are
3200 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
3201 * which are broadcasted in our [`NodeAnnouncement`] message.
3203 * [`NodeAnnouncement`]: crate::ln::msgs::NodeAnnouncement
3205 inline LDK::NodeFeatures provided_node_features();
3207 * Gets the init feature flags which should be sent to the given peer. All available handlers
3208 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
3209 * which are sent in our [`Init`] message.
3211 * [`Init`]: crate::ln::msgs::Init
3213 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
3215 class IgnoringMessageHandler {
3217 LDKIgnoringMessageHandler self;
3219 IgnoringMessageHandler(const IgnoringMessageHandler&) = delete;
3220 IgnoringMessageHandler(IgnoringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(IgnoringMessageHandler)); }
3221 IgnoringMessageHandler(LDKIgnoringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKIgnoringMessageHandler)); }
3222 operator LDKIgnoringMessageHandler() && { LDKIgnoringMessageHandler res = self; memset(&self, 0, sizeof(LDKIgnoringMessageHandler)); return res; }
3223 ~IgnoringMessageHandler() { IgnoringMessageHandler_free(self); }
3224 IgnoringMessageHandler& operator=(IgnoringMessageHandler&& o) { IgnoringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(IgnoringMessageHandler)); return *this; }
3225 LDKIgnoringMessageHandler* operator &() { return &self; }
3226 LDKIgnoringMessageHandler* operator ->() { return &self; }
3227 const LDKIgnoringMessageHandler* operator &() const { return &self; }
3228 const LDKIgnoringMessageHandler* operator ->() const { return &self; }
3230 class ErroringMessageHandler {
3232 LDKErroringMessageHandler self;
3234 ErroringMessageHandler(const ErroringMessageHandler&) = delete;
3235 ErroringMessageHandler(ErroringMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ErroringMessageHandler)); }
3236 ErroringMessageHandler(LDKErroringMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroringMessageHandler)); }
3237 operator LDKErroringMessageHandler() && { LDKErroringMessageHandler res = self; memset(&self, 0, sizeof(LDKErroringMessageHandler)); return res; }
3238 ~ErroringMessageHandler() { ErroringMessageHandler_free(self); }
3239 ErroringMessageHandler& operator=(ErroringMessageHandler&& o) { ErroringMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ErroringMessageHandler)); return *this; }
3240 LDKErroringMessageHandler* operator &() { return &self; }
3241 LDKErroringMessageHandler* operator ->() { return &self; }
3242 const LDKErroringMessageHandler* operator &() const { return &self; }
3243 const LDKErroringMessageHandler* operator ->() const { return &self; }
3245 class MessageHandler {
3247 LDKMessageHandler self;
3249 MessageHandler(const MessageHandler&) = delete;
3250 MessageHandler(MessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(MessageHandler)); }
3251 MessageHandler(LDKMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageHandler)); }
3252 operator LDKMessageHandler() && { LDKMessageHandler res = self; memset(&self, 0, sizeof(LDKMessageHandler)); return res; }
3253 ~MessageHandler() { MessageHandler_free(self); }
3254 MessageHandler& operator=(MessageHandler&& o) { MessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(MessageHandler)); return *this; }
3255 LDKMessageHandler* operator &() { return &self; }
3256 LDKMessageHandler* operator ->() { return &self; }
3257 const LDKMessageHandler* operator &() const { return &self; }
3258 const LDKMessageHandler* operator ->() const { return &self; }
3260 class SocketDescriptor {
3262 LDKSocketDescriptor self;
3264 SocketDescriptor(const SocketDescriptor&) = delete;
3265 SocketDescriptor(SocketDescriptor&& o) : self(o.self) { memset(&o, 0, sizeof(SocketDescriptor)); }
3266 SocketDescriptor(LDKSocketDescriptor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketDescriptor)); }
3267 operator LDKSocketDescriptor() && { LDKSocketDescriptor res = self; memset(&self, 0, sizeof(LDKSocketDescriptor)); return res; }
3268 ~SocketDescriptor() { SocketDescriptor_free(self); }
3269 SocketDescriptor& operator=(SocketDescriptor&& o) { SocketDescriptor_free(self); self = o.self; memset(&o, 0, sizeof(SocketDescriptor)); return *this; }
3270 LDKSocketDescriptor* operator &() { return &self; }
3271 LDKSocketDescriptor* operator ->() { return &self; }
3272 const LDKSocketDescriptor* operator &() const { return &self; }
3273 const LDKSocketDescriptor* operator ->() const { return &self; }
3275 * Attempts to send some data from the given slice to the peer.
3277 * Returns the amount of data which was sent, possibly 0 if the socket has since disconnected.
3278 * Note that in the disconnected case, [`PeerManager::socket_disconnected`] must still be
3279 * called and further write attempts may occur until that time.
3281 * If the returned size is smaller than `data.len()`, a
3282 * [`PeerManager::write_buffer_space_avail`] call must be made the next time more data can be
3283 * written. Additionally, until a `send_data` event completes fully, no further
3284 * [`PeerManager::read_event`] calls should be made for the same peer! Because this is to
3285 * prevent denial-of-service issues, you should not read or buffer any data from the socket
3288 * If a [`PeerManager::read_event`] call on this descriptor had previously returned true
3289 * (indicating that read events should be paused to prevent DoS in the send buffer),
3290 * `resume_read` may be set indicating that read events on this descriptor should resume. A
3291 * `resume_read` of false carries no meaning, and should not cause any action.
3293 inline uintptr_t send_data(struct LDKu8slice data, bool resume_read);
3295 * Disconnect the socket pointed to by this SocketDescriptor.
3297 * You do *not* need to call [`PeerManager::socket_disconnected`] with this socket after this
3298 * call (doing so is a noop).
3300 inline void disconnect_socket();
3301 /** Checks if two objects are equal given this object's this_arg pointer and another object. */
3302 inline bool eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg);
3304 * Calculate a succinct non-cryptographic hash for an object given its this_arg pointer.
3305 * This is used, for example, for inclusion of this object in a hash map.
3307 inline uint64_t hash();
3309 class PeerHandleError {
3311 LDKPeerHandleError self;
3313 PeerHandleError(const PeerHandleError&) = delete;
3314 PeerHandleError(PeerHandleError&& o) : self(o.self) { memset(&o, 0, sizeof(PeerHandleError)); }
3315 PeerHandleError(LDKPeerHandleError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerHandleError)); }
3316 operator LDKPeerHandleError() && { LDKPeerHandleError res = self; memset(&self, 0, sizeof(LDKPeerHandleError)); return res; }
3317 ~PeerHandleError() { PeerHandleError_free(self); }
3318 PeerHandleError& operator=(PeerHandleError&& o) { PeerHandleError_free(self); self = o.self; memset(&o, 0, sizeof(PeerHandleError)); return *this; }
3319 LDKPeerHandleError* operator &() { return &self; }
3320 LDKPeerHandleError* operator ->() { return &self; }
3321 const LDKPeerHandleError* operator &() const { return &self; }
3322 const LDKPeerHandleError* operator ->() const { return &self; }
3326 LDKPeerManager self;
3328 PeerManager(const PeerManager&) = delete;
3329 PeerManager(PeerManager&& o) : self(o.self) { memset(&o, 0, sizeof(PeerManager)); }
3330 PeerManager(LDKPeerManager&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeerManager)); }
3331 operator LDKPeerManager() && { LDKPeerManager res = self; memset(&self, 0, sizeof(LDKPeerManager)); return res; }
3332 ~PeerManager() { PeerManager_free(self); }
3333 PeerManager& operator=(PeerManager&& o) { PeerManager_free(self); self = o.self; memset(&o, 0, sizeof(PeerManager)); return *this; }
3334 LDKPeerManager* operator &() { return &self; }
3335 LDKPeerManager* operator ->() { return &self; }
3336 const LDKPeerManager* operator &() const { return &self; }
3337 const LDKPeerManager* operator ->() const { return &self; }
3339 class GraphSyncError {
3341 LDKGraphSyncError self;
3343 GraphSyncError(const GraphSyncError&) = delete;
3344 GraphSyncError(GraphSyncError&& o) : self(o.self) { memset(&o, 0, sizeof(GraphSyncError)); }
3345 GraphSyncError(LDKGraphSyncError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGraphSyncError)); }
3346 operator LDKGraphSyncError() && { LDKGraphSyncError res = self; memset(&self, 0, sizeof(LDKGraphSyncError)); return res; }
3347 ~GraphSyncError() { GraphSyncError_free(self); }
3348 GraphSyncError& operator=(GraphSyncError&& o) { GraphSyncError_free(self); self = o.self; memset(&o, 0, sizeof(GraphSyncError)); return *this; }
3349 LDKGraphSyncError* operator &() { return &self; }
3350 LDKGraphSyncError* operator ->() { return &self; }
3351 const LDKGraphSyncError* operator &() const { return &self; }
3352 const LDKGraphSyncError* operator ->() const { return &self; }
3354 class RapidGossipSync {
3356 LDKRapidGossipSync self;
3358 RapidGossipSync(const RapidGossipSync&) = delete;
3359 RapidGossipSync(RapidGossipSync&& o) : self(o.self) { memset(&o, 0, sizeof(RapidGossipSync)); }
3360 RapidGossipSync(LDKRapidGossipSync&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRapidGossipSync)); }
3361 operator LDKRapidGossipSync() && { LDKRapidGossipSync res = self; memset(&self, 0, sizeof(LDKRapidGossipSync)); return res; }
3362 ~RapidGossipSync() { RapidGossipSync_free(self); }
3363 RapidGossipSync& operator=(RapidGossipSync&& o) { RapidGossipSync_free(self); self = o.self; memset(&o, 0, sizeof(RapidGossipSync)); return *this; }
3364 LDKRapidGossipSync* operator &() { return &self; }
3365 LDKRapidGossipSync* operator ->() { return &self; }
3366 const LDKRapidGossipSync* operator &() const { return &self; }
3367 const LDKRapidGossipSync* operator ->() const { return &self; }
3373 KVStore(const KVStore&) = delete;
3374 KVStore(KVStore&& o) : self(o.self) { memset(&o, 0, sizeof(KVStore)); }
3375 KVStore(LDKKVStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKKVStore)); }
3376 operator LDKKVStore() && { LDKKVStore res = self; memset(&self, 0, sizeof(LDKKVStore)); return res; }
3377 ~KVStore() { KVStore_free(self); }
3378 KVStore& operator=(KVStore&& o) { KVStore_free(self); self = o.self; memset(&o, 0, sizeof(KVStore)); return *this; }
3379 LDKKVStore* operator &() { return &self; }
3380 LDKKVStore* operator ->() { return &self; }
3381 const LDKKVStore* operator &() const { return &self; }
3382 const LDKKVStore* operator ->() const { return &self; }
3384 * Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and
3387 * Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given
3388 * `primary_namespace` and `secondary_namespace`.
3390 * [`ErrorKind::NotFound`]: io::ErrorKind::NotFound
3392 inline LDK::CResult_CVec_u8ZIOErrorZ read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key);
3394 * Persists the given data under the given `key`.
3396 * Will create the given `primary_namespace` and `secondary_namespace` if not already present
3399 inline LDK::CResult_NoneIOErrorZ write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf);
3401 * Removes any data that had previously been persisted under the given `key`.
3403 * If the `lazy` flag is set to `true`, the backend implementation might choose to lazily
3404 * remove the given `key` at some point in time after the method returns, e.g., as part of an
3405 * eventual batch deletion of multiple keys. As a consequence, subsequent calls to
3406 * [`KVStore::list`] might include the removed key until the changes are actually persisted.
3408 * Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent
3409 * `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could
3410 * potentially get lost on crash after the method returns. Therefore, this flag should only be
3411 * set for `remove` operations that can be safely replayed at a later time.
3413 * Returns successfully if no data will be stored for the given `primary_namespace`,
3414 * `secondary_namespace`, and `key`, independently of whether it was present before its
3415 * invokation or not.
3417 inline LDK::CResult_NoneIOErrorZ remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy);
3419 * Returns a list of keys that are stored under the given `secondary_namespace` in
3420 * `primary_namespace`.
3422 * Returns the keys in arbitrary order, so users requiring a particular order need to sort the
3423 * returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown.
3425 inline LDK::CResult_CVec_StrZIOErrorZ list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace);
3431 Persister(const Persister&) = delete;
3432 Persister(Persister&& o) : self(o.self) { memset(&o, 0, sizeof(Persister)); }
3433 Persister(LDKPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersister)); }
3434 operator LDKPersister() && { LDKPersister res = self; memset(&self, 0, sizeof(LDKPersister)); return res; }
3435 ~Persister() { Persister_free(self); }
3436 Persister& operator=(Persister&& o) { Persister_free(self); self = o.self; memset(&o, 0, sizeof(Persister)); return *this; }
3437 LDKPersister* operator &() { return &self; }
3438 LDKPersister* operator ->() { return &self; }
3439 const LDKPersister* operator &() const { return &self; }
3440 const LDKPersister* operator ->() const { return &self; }
3442 * Persist the given ['ChannelManager'] to disk, returning an error if persistence failed.
3444 inline LDK::CResult_NoneIOErrorZ persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager);
3446 * Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed.
3448 inline LDK::CResult_NoneIOErrorZ persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph);
3450 * Persist the given [`WriteableScore`] to disk, returning an error if persistence failed.
3452 inline LDK::CResult_NoneIOErrorZ persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer);
3454 class MonitorUpdatingPersister {
3456 LDKMonitorUpdatingPersister self;
3458 MonitorUpdatingPersister(const MonitorUpdatingPersister&) = delete;
3459 MonitorUpdatingPersister(MonitorUpdatingPersister&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdatingPersister)); }
3460 MonitorUpdatingPersister(LDKMonitorUpdatingPersister&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdatingPersister)); }
3461 operator LDKMonitorUpdatingPersister() && { LDKMonitorUpdatingPersister res = self; memset(&self, 0, sizeof(LDKMonitorUpdatingPersister)); return res; }
3462 ~MonitorUpdatingPersister() { MonitorUpdatingPersister_free(self); }
3463 MonitorUpdatingPersister& operator=(MonitorUpdatingPersister&& o) { MonitorUpdatingPersister_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdatingPersister)); return *this; }
3464 LDKMonitorUpdatingPersister* operator &() { return &self; }
3465 LDKMonitorUpdatingPersister* operator ->() { return &self; }
3466 const LDKMonitorUpdatingPersister* operator &() const { return &self; }
3467 const LDKMonitorUpdatingPersister* operator ->() const { return &self; }
3469 class UnsignedInvoiceRequest {
3471 LDKUnsignedInvoiceRequest self;
3473 UnsignedInvoiceRequest(const UnsignedInvoiceRequest&) = delete;
3474 UnsignedInvoiceRequest(UnsignedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedInvoiceRequest)); }
3475 UnsignedInvoiceRequest(LDKUnsignedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedInvoiceRequest)); }
3476 operator LDKUnsignedInvoiceRequest() && { LDKUnsignedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKUnsignedInvoiceRequest)); return res; }
3477 ~UnsignedInvoiceRequest() { UnsignedInvoiceRequest_free(self); }
3478 UnsignedInvoiceRequest& operator=(UnsignedInvoiceRequest&& o) { UnsignedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedInvoiceRequest)); return *this; }
3479 LDKUnsignedInvoiceRequest* operator &() { return &self; }
3480 LDKUnsignedInvoiceRequest* operator ->() { return &self; }
3481 const LDKUnsignedInvoiceRequest* operator &() const { return &self; }
3482 const LDKUnsignedInvoiceRequest* operator ->() const { return &self; }
3484 class InvoiceRequest {
3486 LDKInvoiceRequest self;
3488 InvoiceRequest(const InvoiceRequest&) = delete;
3489 InvoiceRequest(InvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceRequest)); }
3490 InvoiceRequest(LDKInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceRequest)); }
3491 operator LDKInvoiceRequest() && { LDKInvoiceRequest res = self; memset(&self, 0, sizeof(LDKInvoiceRequest)); return res; }
3492 ~InvoiceRequest() { InvoiceRequest_free(self); }
3493 InvoiceRequest& operator=(InvoiceRequest&& o) { InvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceRequest)); return *this; }
3494 LDKInvoiceRequest* operator &() { return &self; }
3495 LDKInvoiceRequest* operator ->() { return &self; }
3496 const LDKInvoiceRequest* operator &() const { return &self; }
3497 const LDKInvoiceRequest* operator ->() const { return &self; }
3499 class VerifiedInvoiceRequest {
3501 LDKVerifiedInvoiceRequest self;
3503 VerifiedInvoiceRequest(const VerifiedInvoiceRequest&) = delete;
3504 VerifiedInvoiceRequest(VerifiedInvoiceRequest&& o) : self(o.self) { memset(&o, 0, sizeof(VerifiedInvoiceRequest)); }
3505 VerifiedInvoiceRequest(LDKVerifiedInvoiceRequest&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKVerifiedInvoiceRequest)); }
3506 operator LDKVerifiedInvoiceRequest() && { LDKVerifiedInvoiceRequest res = self; memset(&self, 0, sizeof(LDKVerifiedInvoiceRequest)); return res; }
3507 ~VerifiedInvoiceRequest() { VerifiedInvoiceRequest_free(self); }
3508 VerifiedInvoiceRequest& operator=(VerifiedInvoiceRequest&& o) { VerifiedInvoiceRequest_free(self); self = o.self; memset(&o, 0, sizeof(VerifiedInvoiceRequest)); return *this; }
3509 LDKVerifiedInvoiceRequest* operator &() { return &self; }
3510 LDKVerifiedInvoiceRequest* operator ->() { return &self; }
3511 const LDKVerifiedInvoiceRequest* operator &() const { return &self; }
3512 const LDKVerifiedInvoiceRequest* operator ->() const { return &self; }
3516 LDKDecodeError self;
3518 DecodeError(const DecodeError&) = delete;
3519 DecodeError(DecodeError&& o) : self(o.self) { memset(&o, 0, sizeof(DecodeError)); }
3520 DecodeError(LDKDecodeError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDecodeError)); }
3521 operator LDKDecodeError() && { LDKDecodeError res = self; memset(&self, 0, sizeof(LDKDecodeError)); return res; }
3522 ~DecodeError() { DecodeError_free(self); }
3523 DecodeError& operator=(DecodeError&& o) { DecodeError_free(self); self = o.self; memset(&o, 0, sizeof(DecodeError)); return *this; }
3524 LDKDecodeError* operator &() { return &self; }
3525 LDKDecodeError* operator ->() { return &self; }
3526 const LDKDecodeError* operator &() const { return &self; }
3527 const LDKDecodeError* operator ->() const { return &self; }
3533 Init(const Init&) = delete;
3534 Init(Init&& o) : self(o.self) { memset(&o, 0, sizeof(Init)); }
3535 Init(LDKInit&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInit)); }
3536 operator LDKInit() && { LDKInit res = self; memset(&self, 0, sizeof(LDKInit)); return res; }
3537 ~Init() { Init_free(self); }
3538 Init& operator=(Init&& o) { Init_free(self); self = o.self; memset(&o, 0, sizeof(Init)); return *this; }
3539 LDKInit* operator &() { return &self; }
3540 LDKInit* operator ->() { return &self; }
3541 const LDKInit* operator &() const { return &self; }
3542 const LDKInit* operator ->() const { return &self; }
3544 class ErrorMessage {
3546 LDKErrorMessage self;
3548 ErrorMessage(const ErrorMessage&) = delete;
3549 ErrorMessage(ErrorMessage&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorMessage)); }
3550 ErrorMessage(LDKErrorMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorMessage)); }
3551 operator LDKErrorMessage() && { LDKErrorMessage res = self; memset(&self, 0, sizeof(LDKErrorMessage)); return res; }
3552 ~ErrorMessage() { ErrorMessage_free(self); }
3553 ErrorMessage& operator=(ErrorMessage&& o) { ErrorMessage_free(self); self = o.self; memset(&o, 0, sizeof(ErrorMessage)); return *this; }
3554 LDKErrorMessage* operator &() { return &self; }
3555 LDKErrorMessage* operator ->() { return &self; }
3556 const LDKErrorMessage* operator &() const { return &self; }
3557 const LDKErrorMessage* operator ->() const { return &self; }
3559 class WarningMessage {
3561 LDKWarningMessage self;
3563 WarningMessage(const WarningMessage&) = delete;
3564 WarningMessage(WarningMessage&& o) : self(o.self) { memset(&o, 0, sizeof(WarningMessage)); }
3565 WarningMessage(LDKWarningMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKWarningMessage)); }
3566 operator LDKWarningMessage() && { LDKWarningMessage res = self; memset(&self, 0, sizeof(LDKWarningMessage)); return res; }
3567 ~WarningMessage() { WarningMessage_free(self); }
3568 WarningMessage& operator=(WarningMessage&& o) { WarningMessage_free(self); self = o.self; memset(&o, 0, sizeof(WarningMessage)); return *this; }
3569 LDKWarningMessage* operator &() { return &self; }
3570 LDKWarningMessage* operator ->() { return &self; }
3571 const LDKWarningMessage* operator &() const { return &self; }
3572 const LDKWarningMessage* operator ->() const { return &self; }
3578 Ping(const Ping&) = delete;
3579 Ping(Ping&& o) : self(o.self) { memset(&o, 0, sizeof(Ping)); }
3580 Ping(LDKPing&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPing)); }
3581 operator LDKPing() && { LDKPing res = self; memset(&self, 0, sizeof(LDKPing)); return res; }
3582 ~Ping() { Ping_free(self); }
3583 Ping& operator=(Ping&& o) { Ping_free(self); self = o.self; memset(&o, 0, sizeof(Ping)); return *this; }
3584 LDKPing* operator &() { return &self; }
3585 LDKPing* operator ->() { return &self; }
3586 const LDKPing* operator &() const { return &self; }
3587 const LDKPing* operator ->() const { return &self; }
3593 Pong(const Pong&) = delete;
3594 Pong(Pong&& o) : self(o.self) { memset(&o, 0, sizeof(Pong)); }
3595 Pong(LDKPong&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPong)); }
3596 operator LDKPong() && { LDKPong res = self; memset(&self, 0, sizeof(LDKPong)); return res; }
3597 ~Pong() { Pong_free(self); }
3598 Pong& operator=(Pong&& o) { Pong_free(self); self = o.self; memset(&o, 0, sizeof(Pong)); return *this; }
3599 LDKPong* operator &() { return &self; }
3600 LDKPong* operator ->() { return &self; }
3601 const LDKPong* operator &() const { return &self; }
3602 const LDKPong* operator ->() const { return &self; }
3606 LDKOpenChannel self;
3608 OpenChannel(const OpenChannel&) = delete;
3609 OpenChannel(OpenChannel&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannel)); }
3610 OpenChannel(LDKOpenChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannel)); }
3611 operator LDKOpenChannel() && { LDKOpenChannel res = self; memset(&self, 0, sizeof(LDKOpenChannel)); return res; }
3612 ~OpenChannel() { OpenChannel_free(self); }
3613 OpenChannel& operator=(OpenChannel&& o) { OpenChannel_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannel)); return *this; }
3614 LDKOpenChannel* operator &() { return &self; }
3615 LDKOpenChannel* operator ->() { return &self; }
3616 const LDKOpenChannel* operator &() const { return &self; }
3617 const LDKOpenChannel* operator ->() const { return &self; }
3619 class OpenChannelV2 {
3621 LDKOpenChannelV2 self;
3623 OpenChannelV2(const OpenChannelV2&) = delete;
3624 OpenChannelV2(OpenChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(OpenChannelV2)); }
3625 OpenChannelV2(LDKOpenChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOpenChannelV2)); }
3626 operator LDKOpenChannelV2() && { LDKOpenChannelV2 res = self; memset(&self, 0, sizeof(LDKOpenChannelV2)); return res; }
3627 ~OpenChannelV2() { OpenChannelV2_free(self); }
3628 OpenChannelV2& operator=(OpenChannelV2&& o) { OpenChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(OpenChannelV2)); return *this; }
3629 LDKOpenChannelV2* operator &() { return &self; }
3630 LDKOpenChannelV2* operator ->() { return &self; }
3631 const LDKOpenChannelV2* operator &() const { return &self; }
3632 const LDKOpenChannelV2* operator ->() const { return &self; }
3634 class AcceptChannel {
3636 LDKAcceptChannel self;
3638 AcceptChannel(const AcceptChannel&) = delete;
3639 AcceptChannel(AcceptChannel&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannel)); }
3640 AcceptChannel(LDKAcceptChannel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannel)); }
3641 operator LDKAcceptChannel() && { LDKAcceptChannel res = self; memset(&self, 0, sizeof(LDKAcceptChannel)); return res; }
3642 ~AcceptChannel() { AcceptChannel_free(self); }
3643 AcceptChannel& operator=(AcceptChannel&& o) { AcceptChannel_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannel)); return *this; }
3644 LDKAcceptChannel* operator &() { return &self; }
3645 LDKAcceptChannel* operator ->() { return &self; }
3646 const LDKAcceptChannel* operator &() const { return &self; }
3647 const LDKAcceptChannel* operator ->() const { return &self; }
3649 class AcceptChannelV2 {
3651 LDKAcceptChannelV2 self;
3653 AcceptChannelV2(const AcceptChannelV2&) = delete;
3654 AcceptChannelV2(AcceptChannelV2&& o) : self(o.self) { memset(&o, 0, sizeof(AcceptChannelV2)); }
3655 AcceptChannelV2(LDKAcceptChannelV2&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAcceptChannelV2)); }
3656 operator LDKAcceptChannelV2() && { LDKAcceptChannelV2 res = self; memset(&self, 0, sizeof(LDKAcceptChannelV2)); return res; }
3657 ~AcceptChannelV2() { AcceptChannelV2_free(self); }
3658 AcceptChannelV2& operator=(AcceptChannelV2&& o) { AcceptChannelV2_free(self); self = o.self; memset(&o, 0, sizeof(AcceptChannelV2)); return *this; }
3659 LDKAcceptChannelV2* operator &() { return &self; }
3660 LDKAcceptChannelV2* operator ->() { return &self; }
3661 const LDKAcceptChannelV2* operator &() const { return &self; }
3662 const LDKAcceptChannelV2* operator ->() const { return &self; }
3664 class FundingCreated {
3666 LDKFundingCreated self;
3668 FundingCreated(const FundingCreated&) = delete;
3669 FundingCreated(FundingCreated&& o) : self(o.self) { memset(&o, 0, sizeof(FundingCreated)); }
3670 FundingCreated(LDKFundingCreated&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingCreated)); }
3671 operator LDKFundingCreated() && { LDKFundingCreated res = self; memset(&self, 0, sizeof(LDKFundingCreated)); return res; }
3672 ~FundingCreated() { FundingCreated_free(self); }
3673 FundingCreated& operator=(FundingCreated&& o) { FundingCreated_free(self); self = o.self; memset(&o, 0, sizeof(FundingCreated)); return *this; }
3674 LDKFundingCreated* operator &() { return &self; }
3675 LDKFundingCreated* operator ->() { return &self; }
3676 const LDKFundingCreated* operator &() const { return &self; }
3677 const LDKFundingCreated* operator ->() const { return &self; }
3679 class FundingSigned {
3681 LDKFundingSigned self;
3683 FundingSigned(const FundingSigned&) = delete;
3684 FundingSigned(FundingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(FundingSigned)); }
3685 FundingSigned(LDKFundingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFundingSigned)); }
3686 operator LDKFundingSigned() && { LDKFundingSigned res = self; memset(&self, 0, sizeof(LDKFundingSigned)); return res; }
3687 ~FundingSigned() { FundingSigned_free(self); }
3688 FundingSigned& operator=(FundingSigned&& o) { FundingSigned_free(self); self = o.self; memset(&o, 0, sizeof(FundingSigned)); return *this; }
3689 LDKFundingSigned* operator &() { return &self; }
3690 LDKFundingSigned* operator ->() { return &self; }
3691 const LDKFundingSigned* operator &() const { return &self; }
3692 const LDKFundingSigned* operator ->() const { return &self; }
3694 class ChannelReady {
3696 LDKChannelReady self;
3698 ChannelReady(const ChannelReady&) = delete;
3699 ChannelReady(ChannelReady&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReady)); }
3700 ChannelReady(LDKChannelReady&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReady)); }
3701 operator LDKChannelReady() && { LDKChannelReady res = self; memset(&self, 0, sizeof(LDKChannelReady)); return res; }
3702 ~ChannelReady() { ChannelReady_free(self); }
3703 ChannelReady& operator=(ChannelReady&& o) { ChannelReady_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReady)); return *this; }
3704 LDKChannelReady* operator &() { return &self; }
3705 LDKChannelReady* operator ->() { return &self; }
3706 const LDKChannelReady* operator &() const { return &self; }
3707 const LDKChannelReady* operator ->() const { return &self; }
3713 Stfu(const Stfu&) = delete;
3714 Stfu(Stfu&& o) : self(o.self) { memset(&o, 0, sizeof(Stfu)); }
3715 Stfu(LDKStfu&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKStfu)); }
3716 operator LDKStfu() && { LDKStfu res = self; memset(&self, 0, sizeof(LDKStfu)); return res; }
3717 ~Stfu() { Stfu_free(self); }
3718 Stfu& operator=(Stfu&& o) { Stfu_free(self); self = o.self; memset(&o, 0, sizeof(Stfu)); return *this; }
3719 LDKStfu* operator &() { return &self; }
3720 LDKStfu* operator ->() { return &self; }
3721 const LDKStfu* operator &() const { return &self; }
3722 const LDKStfu* operator ->() const { return &self; }
3728 Splice(const Splice&) = delete;
3729 Splice(Splice&& o) : self(o.self) { memset(&o, 0, sizeof(Splice)); }
3730 Splice(LDKSplice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSplice)); }
3731 operator LDKSplice() && { LDKSplice res = self; memset(&self, 0, sizeof(LDKSplice)); return res; }
3732 ~Splice() { Splice_free(self); }
3733 Splice& operator=(Splice&& o) { Splice_free(self); self = o.self; memset(&o, 0, sizeof(Splice)); return *this; }
3734 LDKSplice* operator &() { return &self; }
3735 LDKSplice* operator ->() { return &self; }
3736 const LDKSplice* operator &() const { return &self; }
3737 const LDKSplice* operator ->() const { return &self; }
3743 SpliceAck(const SpliceAck&) = delete;
3744 SpliceAck(SpliceAck&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceAck)); }
3745 SpliceAck(LDKSpliceAck&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceAck)); }
3746 operator LDKSpliceAck() && { LDKSpliceAck res = self; memset(&self, 0, sizeof(LDKSpliceAck)); return res; }
3747 ~SpliceAck() { SpliceAck_free(self); }
3748 SpliceAck& operator=(SpliceAck&& o) { SpliceAck_free(self); self = o.self; memset(&o, 0, sizeof(SpliceAck)); return *this; }
3749 LDKSpliceAck* operator &() { return &self; }
3750 LDKSpliceAck* operator ->() { return &self; }
3751 const LDKSpliceAck* operator &() const { return &self; }
3752 const LDKSpliceAck* operator ->() const { return &self; }
3754 class SpliceLocked {
3756 LDKSpliceLocked self;
3758 SpliceLocked(const SpliceLocked&) = delete;
3759 SpliceLocked(SpliceLocked&& o) : self(o.self) { memset(&o, 0, sizeof(SpliceLocked)); }
3760 SpliceLocked(LDKSpliceLocked&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSpliceLocked)); }
3761 operator LDKSpliceLocked() && { LDKSpliceLocked res = self; memset(&self, 0, sizeof(LDKSpliceLocked)); return res; }
3762 ~SpliceLocked() { SpliceLocked_free(self); }
3763 SpliceLocked& operator=(SpliceLocked&& o) { SpliceLocked_free(self); self = o.self; memset(&o, 0, sizeof(SpliceLocked)); return *this; }
3764 LDKSpliceLocked* operator &() { return &self; }
3765 LDKSpliceLocked* operator ->() { return &self; }
3766 const LDKSpliceLocked* operator &() const { return &self; }
3767 const LDKSpliceLocked* operator ->() const { return &self; }
3773 TxAddInput(const TxAddInput&) = delete;
3774 TxAddInput(TxAddInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddInput)); }
3775 TxAddInput(LDKTxAddInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddInput)); }
3776 operator LDKTxAddInput() && { LDKTxAddInput res = self; memset(&self, 0, sizeof(LDKTxAddInput)); return res; }
3777 ~TxAddInput() { TxAddInput_free(self); }
3778 TxAddInput& operator=(TxAddInput&& o) { TxAddInput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddInput)); return *this; }
3779 LDKTxAddInput* operator &() { return &self; }
3780 LDKTxAddInput* operator ->() { return &self; }
3781 const LDKTxAddInput* operator &() const { return &self; }
3782 const LDKTxAddInput* operator ->() const { return &self; }
3786 LDKTxAddOutput self;
3788 TxAddOutput(const TxAddOutput&) = delete;
3789 TxAddOutput(TxAddOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxAddOutput)); }
3790 TxAddOutput(LDKTxAddOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAddOutput)); }
3791 operator LDKTxAddOutput() && { LDKTxAddOutput res = self; memset(&self, 0, sizeof(LDKTxAddOutput)); return res; }
3792 ~TxAddOutput() { TxAddOutput_free(self); }
3793 TxAddOutput& operator=(TxAddOutput&& o) { TxAddOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxAddOutput)); return *this; }
3794 LDKTxAddOutput* operator &() { return &self; }
3795 LDKTxAddOutput* operator ->() { return &self; }
3796 const LDKTxAddOutput* operator &() const { return &self; }
3797 const LDKTxAddOutput* operator ->() const { return &self; }
3799 class TxRemoveInput {
3801 LDKTxRemoveInput self;
3803 TxRemoveInput(const TxRemoveInput&) = delete;
3804 TxRemoveInput(TxRemoveInput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveInput)); }
3805 TxRemoveInput(LDKTxRemoveInput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveInput)); }
3806 operator LDKTxRemoveInput() && { LDKTxRemoveInput res = self; memset(&self, 0, sizeof(LDKTxRemoveInput)); return res; }
3807 ~TxRemoveInput() { TxRemoveInput_free(self); }
3808 TxRemoveInput& operator=(TxRemoveInput&& o) { TxRemoveInput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveInput)); return *this; }
3809 LDKTxRemoveInput* operator &() { return &self; }
3810 LDKTxRemoveInput* operator ->() { return &self; }
3811 const LDKTxRemoveInput* operator &() const { return &self; }
3812 const LDKTxRemoveInput* operator ->() const { return &self; }
3814 class TxRemoveOutput {
3816 LDKTxRemoveOutput self;
3818 TxRemoveOutput(const TxRemoveOutput&) = delete;
3819 TxRemoveOutput(TxRemoveOutput&& o) : self(o.self) { memset(&o, 0, sizeof(TxRemoveOutput)); }
3820 TxRemoveOutput(LDKTxRemoveOutput&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxRemoveOutput)); }
3821 operator LDKTxRemoveOutput() && { LDKTxRemoveOutput res = self; memset(&self, 0, sizeof(LDKTxRemoveOutput)); return res; }
3822 ~TxRemoveOutput() { TxRemoveOutput_free(self); }
3823 TxRemoveOutput& operator=(TxRemoveOutput&& o) { TxRemoveOutput_free(self); self = o.self; memset(&o, 0, sizeof(TxRemoveOutput)); return *this; }
3824 LDKTxRemoveOutput* operator &() { return &self; }
3825 LDKTxRemoveOutput* operator ->() { return &self; }
3826 const LDKTxRemoveOutput* operator &() const { return &self; }
3827 const LDKTxRemoveOutput* operator ->() const { return &self; }
3833 TxComplete(const TxComplete&) = delete;
3834 TxComplete(TxComplete&& o) : self(o.self) { memset(&o, 0, sizeof(TxComplete)); }
3835 TxComplete(LDKTxComplete&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxComplete)); }
3836 operator LDKTxComplete() && { LDKTxComplete res = self; memset(&self, 0, sizeof(LDKTxComplete)); return res; }
3837 ~TxComplete() { TxComplete_free(self); }
3838 TxComplete& operator=(TxComplete&& o) { TxComplete_free(self); self = o.self; memset(&o, 0, sizeof(TxComplete)); return *this; }
3839 LDKTxComplete* operator &() { return &self; }
3840 LDKTxComplete* operator ->() { return &self; }
3841 const LDKTxComplete* operator &() const { return &self; }
3842 const LDKTxComplete* operator ->() const { return &self; }
3844 class TxSignatures {
3846 LDKTxSignatures self;
3848 TxSignatures(const TxSignatures&) = delete;
3849 TxSignatures(TxSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(TxSignatures)); }
3850 TxSignatures(LDKTxSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxSignatures)); }
3851 operator LDKTxSignatures() && { LDKTxSignatures res = self; memset(&self, 0, sizeof(LDKTxSignatures)); return res; }
3852 ~TxSignatures() { TxSignatures_free(self); }
3853 TxSignatures& operator=(TxSignatures&& o) { TxSignatures_free(self); self = o.self; memset(&o, 0, sizeof(TxSignatures)); return *this; }
3854 LDKTxSignatures* operator &() { return &self; }
3855 LDKTxSignatures* operator ->() { return &self; }
3856 const LDKTxSignatures* operator &() const { return &self; }
3857 const LDKTxSignatures* operator ->() const { return &self; }
3863 TxInitRbf(const TxInitRbf&) = delete;
3864 TxInitRbf(TxInitRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxInitRbf)); }
3865 TxInitRbf(LDKTxInitRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxInitRbf)); }
3866 operator LDKTxInitRbf() && { LDKTxInitRbf res = self; memset(&self, 0, sizeof(LDKTxInitRbf)); return res; }
3867 ~TxInitRbf() { TxInitRbf_free(self); }
3868 TxInitRbf& operator=(TxInitRbf&& o) { TxInitRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxInitRbf)); return *this; }
3869 LDKTxInitRbf* operator &() { return &self; }
3870 LDKTxInitRbf* operator ->() { return &self; }
3871 const LDKTxInitRbf* operator &() const { return &self; }
3872 const LDKTxInitRbf* operator ->() const { return &self; }
3878 TxAckRbf(const TxAckRbf&) = delete;
3879 TxAckRbf(TxAckRbf&& o) : self(o.self) { memset(&o, 0, sizeof(TxAckRbf)); }
3880 TxAckRbf(LDKTxAckRbf&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAckRbf)); }
3881 operator LDKTxAckRbf() && { LDKTxAckRbf res = self; memset(&self, 0, sizeof(LDKTxAckRbf)); return res; }
3882 ~TxAckRbf() { TxAckRbf_free(self); }
3883 TxAckRbf& operator=(TxAckRbf&& o) { TxAckRbf_free(self); self = o.self; memset(&o, 0, sizeof(TxAckRbf)); return *this; }
3884 LDKTxAckRbf* operator &() { return &self; }
3885 LDKTxAckRbf* operator ->() { return &self; }
3886 const LDKTxAckRbf* operator &() const { return &self; }
3887 const LDKTxAckRbf* operator ->() const { return &self; }
3893 TxAbort(const TxAbort&) = delete;
3894 TxAbort(TxAbort&& o) : self(o.self) { memset(&o, 0, sizeof(TxAbort)); }
3895 TxAbort(LDKTxAbort&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxAbort)); }
3896 operator LDKTxAbort() && { LDKTxAbort res = self; memset(&self, 0, sizeof(LDKTxAbort)); return res; }
3897 ~TxAbort() { TxAbort_free(self); }
3898 TxAbort& operator=(TxAbort&& o) { TxAbort_free(self); self = o.self; memset(&o, 0, sizeof(TxAbort)); return *this; }
3899 LDKTxAbort* operator &() { return &self; }
3900 LDKTxAbort* operator ->() { return &self; }
3901 const LDKTxAbort* operator &() const { return &self; }
3902 const LDKTxAbort* operator ->() const { return &self; }
3908 Shutdown(const Shutdown&) = delete;
3909 Shutdown(Shutdown&& o) : self(o.self) { memset(&o, 0, sizeof(Shutdown)); }
3910 Shutdown(LDKShutdown&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdown)); }
3911 operator LDKShutdown() && { LDKShutdown res = self; memset(&self, 0, sizeof(LDKShutdown)); return res; }
3912 ~Shutdown() { Shutdown_free(self); }
3913 Shutdown& operator=(Shutdown&& o) { Shutdown_free(self); self = o.self; memset(&o, 0, sizeof(Shutdown)); return *this; }
3914 LDKShutdown* operator &() { return &self; }
3915 LDKShutdown* operator ->() { return &self; }
3916 const LDKShutdown* operator &() const { return &self; }
3917 const LDKShutdown* operator ->() const { return &self; }
3919 class ClosingSignedFeeRange {
3921 LDKClosingSignedFeeRange self;
3923 ClosingSignedFeeRange(const ClosingSignedFeeRange&) = delete;
3924 ClosingSignedFeeRange(ClosingSignedFeeRange&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSignedFeeRange)); }
3925 ClosingSignedFeeRange(LDKClosingSignedFeeRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSignedFeeRange)); }
3926 operator LDKClosingSignedFeeRange() && { LDKClosingSignedFeeRange res = self; memset(&self, 0, sizeof(LDKClosingSignedFeeRange)); return res; }
3927 ~ClosingSignedFeeRange() { ClosingSignedFeeRange_free(self); }
3928 ClosingSignedFeeRange& operator=(ClosingSignedFeeRange&& o) { ClosingSignedFeeRange_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSignedFeeRange)); return *this; }
3929 LDKClosingSignedFeeRange* operator &() { return &self; }
3930 LDKClosingSignedFeeRange* operator ->() { return &self; }
3931 const LDKClosingSignedFeeRange* operator &() const { return &self; }
3932 const LDKClosingSignedFeeRange* operator ->() const { return &self; }
3934 class ClosingSigned {
3936 LDKClosingSigned self;
3938 ClosingSigned(const ClosingSigned&) = delete;
3939 ClosingSigned(ClosingSigned&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingSigned)); }
3940 ClosingSigned(LDKClosingSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingSigned)); }
3941 operator LDKClosingSigned() && { LDKClosingSigned res = self; memset(&self, 0, sizeof(LDKClosingSigned)); return res; }
3942 ~ClosingSigned() { ClosingSigned_free(self); }
3943 ClosingSigned& operator=(ClosingSigned&& o) { ClosingSigned_free(self); self = o.self; memset(&o, 0, sizeof(ClosingSigned)); return *this; }
3944 LDKClosingSigned* operator &() { return &self; }
3945 LDKClosingSigned* operator ->() { return &self; }
3946 const LDKClosingSigned* operator &() const { return &self; }
3947 const LDKClosingSigned* operator ->() const { return &self; }
3949 class UpdateAddHTLC {
3951 LDKUpdateAddHTLC self;
3953 UpdateAddHTLC(const UpdateAddHTLC&) = delete;
3954 UpdateAddHTLC(UpdateAddHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateAddHTLC)); }
3955 UpdateAddHTLC(LDKUpdateAddHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateAddHTLC)); }
3956 operator LDKUpdateAddHTLC() && { LDKUpdateAddHTLC res = self; memset(&self, 0, sizeof(LDKUpdateAddHTLC)); return res; }
3957 ~UpdateAddHTLC() { UpdateAddHTLC_free(self); }
3958 UpdateAddHTLC& operator=(UpdateAddHTLC&& o) { UpdateAddHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateAddHTLC)); return *this; }
3959 LDKUpdateAddHTLC* operator &() { return &self; }
3960 LDKUpdateAddHTLC* operator ->() { return &self; }
3961 const LDKUpdateAddHTLC* operator &() const { return &self; }
3962 const LDKUpdateAddHTLC* operator ->() const { return &self; }
3964 class OnionMessage {
3966 LDKOnionMessage self;
3968 OnionMessage(const OnionMessage&) = delete;
3969 OnionMessage(OnionMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessage)); }
3970 OnionMessage(LDKOnionMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessage)); }
3971 operator LDKOnionMessage() && { LDKOnionMessage res = self; memset(&self, 0, sizeof(LDKOnionMessage)); return res; }
3972 ~OnionMessage() { OnionMessage_free(self); }
3973 OnionMessage& operator=(OnionMessage&& o) { OnionMessage_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessage)); return *this; }
3974 LDKOnionMessage* operator &() { return &self; }
3975 LDKOnionMessage* operator ->() { return &self; }
3976 const LDKOnionMessage* operator &() const { return &self; }
3977 const LDKOnionMessage* operator ->() const { return &self; }
3979 class UpdateFulfillHTLC {
3981 LDKUpdateFulfillHTLC self;
3983 UpdateFulfillHTLC(const UpdateFulfillHTLC&) = delete;
3984 UpdateFulfillHTLC(UpdateFulfillHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFulfillHTLC)); }
3985 UpdateFulfillHTLC(LDKUpdateFulfillHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFulfillHTLC)); }
3986 operator LDKUpdateFulfillHTLC() && { LDKUpdateFulfillHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFulfillHTLC)); return res; }
3987 ~UpdateFulfillHTLC() { UpdateFulfillHTLC_free(self); }
3988 UpdateFulfillHTLC& operator=(UpdateFulfillHTLC&& o) { UpdateFulfillHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFulfillHTLC)); return *this; }
3989 LDKUpdateFulfillHTLC* operator &() { return &self; }
3990 LDKUpdateFulfillHTLC* operator ->() { return &self; }
3991 const LDKUpdateFulfillHTLC* operator &() const { return &self; }
3992 const LDKUpdateFulfillHTLC* operator ->() const { return &self; }
3994 class UpdateFailHTLC {
3996 LDKUpdateFailHTLC self;
3998 UpdateFailHTLC(const UpdateFailHTLC&) = delete;
3999 UpdateFailHTLC(UpdateFailHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailHTLC)); }
4000 UpdateFailHTLC(LDKUpdateFailHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailHTLC)); }
4001 operator LDKUpdateFailHTLC() && { LDKUpdateFailHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailHTLC)); return res; }
4002 ~UpdateFailHTLC() { UpdateFailHTLC_free(self); }
4003 UpdateFailHTLC& operator=(UpdateFailHTLC&& o) { UpdateFailHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailHTLC)); return *this; }
4004 LDKUpdateFailHTLC* operator &() { return &self; }
4005 LDKUpdateFailHTLC* operator ->() { return &self; }
4006 const LDKUpdateFailHTLC* operator &() const { return &self; }
4007 const LDKUpdateFailHTLC* operator ->() const { return &self; }
4009 class UpdateFailMalformedHTLC {
4011 LDKUpdateFailMalformedHTLC self;
4013 UpdateFailMalformedHTLC(const UpdateFailMalformedHTLC&) = delete;
4014 UpdateFailMalformedHTLC(UpdateFailMalformedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); }
4015 UpdateFailMalformedHTLC(LDKUpdateFailMalformedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFailMalformedHTLC)); }
4016 operator LDKUpdateFailMalformedHTLC() && { LDKUpdateFailMalformedHTLC res = self; memset(&self, 0, sizeof(LDKUpdateFailMalformedHTLC)); return res; }
4017 ~UpdateFailMalformedHTLC() { UpdateFailMalformedHTLC_free(self); }
4018 UpdateFailMalformedHTLC& operator=(UpdateFailMalformedHTLC&& o) { UpdateFailMalformedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFailMalformedHTLC)); return *this; }
4019 LDKUpdateFailMalformedHTLC* operator &() { return &self; }
4020 LDKUpdateFailMalformedHTLC* operator ->() { return &self; }
4021 const LDKUpdateFailMalformedHTLC* operator &() const { return &self; }
4022 const LDKUpdateFailMalformedHTLC* operator ->() const { return &self; }
4024 class CommitmentSigned {
4026 LDKCommitmentSigned self;
4028 CommitmentSigned(const CommitmentSigned&) = delete;
4029 CommitmentSigned(CommitmentSigned&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentSigned)); }
4030 CommitmentSigned(LDKCommitmentSigned&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentSigned)); }
4031 operator LDKCommitmentSigned() && { LDKCommitmentSigned res = self; memset(&self, 0, sizeof(LDKCommitmentSigned)); return res; }
4032 ~CommitmentSigned() { CommitmentSigned_free(self); }
4033 CommitmentSigned& operator=(CommitmentSigned&& o) { CommitmentSigned_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentSigned)); return *this; }
4034 LDKCommitmentSigned* operator &() { return &self; }
4035 LDKCommitmentSigned* operator ->() { return &self; }
4036 const LDKCommitmentSigned* operator &() const { return &self; }
4037 const LDKCommitmentSigned* operator ->() const { return &self; }
4039 class RevokeAndACK {
4041 LDKRevokeAndACK self;
4043 RevokeAndACK(const RevokeAndACK&) = delete;
4044 RevokeAndACK(RevokeAndACK&& o) : self(o.self) { memset(&o, 0, sizeof(RevokeAndACK)); }
4045 RevokeAndACK(LDKRevokeAndACK&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevokeAndACK)); }
4046 operator LDKRevokeAndACK() && { LDKRevokeAndACK res = self; memset(&self, 0, sizeof(LDKRevokeAndACK)); return res; }
4047 ~RevokeAndACK() { RevokeAndACK_free(self); }
4048 RevokeAndACK& operator=(RevokeAndACK&& o) { RevokeAndACK_free(self); self = o.self; memset(&o, 0, sizeof(RevokeAndACK)); return *this; }
4049 LDKRevokeAndACK* operator &() { return &self; }
4050 LDKRevokeAndACK* operator ->() { return &self; }
4051 const LDKRevokeAndACK* operator &() const { return &self; }
4052 const LDKRevokeAndACK* operator ->() const { return &self; }
4058 UpdateFee(const UpdateFee&) = delete;
4059 UpdateFee(UpdateFee&& o) : self(o.self) { memset(&o, 0, sizeof(UpdateFee)); }
4060 UpdateFee(LDKUpdateFee&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUpdateFee)); }
4061 operator LDKUpdateFee() && { LDKUpdateFee res = self; memset(&self, 0, sizeof(LDKUpdateFee)); return res; }
4062 ~UpdateFee() { UpdateFee_free(self); }
4063 UpdateFee& operator=(UpdateFee&& o) { UpdateFee_free(self); self = o.self; memset(&o, 0, sizeof(UpdateFee)); return *this; }
4064 LDKUpdateFee* operator &() { return &self; }
4065 LDKUpdateFee* operator ->() { return &self; }
4066 const LDKUpdateFee* operator &() const { return &self; }
4067 const LDKUpdateFee* operator ->() const { return &self; }
4069 class ChannelReestablish {
4071 LDKChannelReestablish self;
4073 ChannelReestablish(const ChannelReestablish&) = delete;
4074 ChannelReestablish(ChannelReestablish&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelReestablish)); }
4075 ChannelReestablish(LDKChannelReestablish&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelReestablish)); }
4076 operator LDKChannelReestablish() && { LDKChannelReestablish res = self; memset(&self, 0, sizeof(LDKChannelReestablish)); return res; }
4077 ~ChannelReestablish() { ChannelReestablish_free(self); }
4078 ChannelReestablish& operator=(ChannelReestablish&& o) { ChannelReestablish_free(self); self = o.self; memset(&o, 0, sizeof(ChannelReestablish)); return *this; }
4079 LDKChannelReestablish* operator &() { return &self; }
4080 LDKChannelReestablish* operator ->() { return &self; }
4081 const LDKChannelReestablish* operator &() const { return &self; }
4082 const LDKChannelReestablish* operator ->() const { return &self; }
4084 class AnnouncementSignatures {
4086 LDKAnnouncementSignatures self;
4088 AnnouncementSignatures(const AnnouncementSignatures&) = delete;
4089 AnnouncementSignatures(AnnouncementSignatures&& o) : self(o.self) { memset(&o, 0, sizeof(AnnouncementSignatures)); }
4090 AnnouncementSignatures(LDKAnnouncementSignatures&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKAnnouncementSignatures)); }
4091 operator LDKAnnouncementSignatures() && { LDKAnnouncementSignatures res = self; memset(&self, 0, sizeof(LDKAnnouncementSignatures)); return res; }
4092 ~AnnouncementSignatures() { AnnouncementSignatures_free(self); }
4093 AnnouncementSignatures& operator=(AnnouncementSignatures&& o) { AnnouncementSignatures_free(self); self = o.self; memset(&o, 0, sizeof(AnnouncementSignatures)); return *this; }
4094 LDKAnnouncementSignatures* operator &() { return &self; }
4095 LDKAnnouncementSignatures* operator ->() { return &self; }
4096 const LDKAnnouncementSignatures* operator &() const { return &self; }
4097 const LDKAnnouncementSignatures* operator ->() const { return &self; }
4099 class SocketAddress {
4101 LDKSocketAddress self;
4103 SocketAddress(const SocketAddress&) = delete;
4104 SocketAddress(SocketAddress&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddress)); }
4105 SocketAddress(LDKSocketAddress&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddress)); }
4106 operator LDKSocketAddress() && { LDKSocketAddress res = self; memset(&self, 0, sizeof(LDKSocketAddress)); return res; }
4107 ~SocketAddress() { SocketAddress_free(self); }
4108 SocketAddress& operator=(SocketAddress&& o) { SocketAddress_free(self); self = o.self; memset(&o, 0, sizeof(SocketAddress)); return *this; }
4109 LDKSocketAddress* operator &() { return &self; }
4110 LDKSocketAddress* operator ->() { return &self; }
4111 const LDKSocketAddress* operator &() const { return &self; }
4112 const LDKSocketAddress* operator ->() const { return &self; }
4114 class SocketAddressParseError {
4116 LDKSocketAddressParseError self;
4118 SocketAddressParseError(const SocketAddressParseError&) = delete;
4119 SocketAddressParseError(SocketAddressParseError&& o) : self(o.self) { memset(&o, 0, sizeof(SocketAddressParseError)); }
4120 SocketAddressParseError(LDKSocketAddressParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSocketAddressParseError)); }
4121 operator LDKSocketAddressParseError() && { LDKSocketAddressParseError res = self; memset(&self, 0, sizeof(LDKSocketAddressParseError)); return res; }
4122 SocketAddressParseError& operator=(SocketAddressParseError&& o) { self = o.self; memset(&o, 0, sizeof(SocketAddressParseError)); return *this; }
4123 LDKSocketAddressParseError* operator &() { return &self; }
4124 LDKSocketAddressParseError* operator ->() { return &self; }
4125 const LDKSocketAddressParseError* operator &() const { return &self; }
4126 const LDKSocketAddressParseError* operator ->() const { return &self; }
4128 class UnsignedGossipMessage {
4130 LDKUnsignedGossipMessage self;
4132 UnsignedGossipMessage(const UnsignedGossipMessage&) = delete;
4133 UnsignedGossipMessage(UnsignedGossipMessage&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedGossipMessage)); }
4134 UnsignedGossipMessage(LDKUnsignedGossipMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedGossipMessage)); }
4135 operator LDKUnsignedGossipMessage() && { LDKUnsignedGossipMessage res = self; memset(&self, 0, sizeof(LDKUnsignedGossipMessage)); return res; }
4136 ~UnsignedGossipMessage() { UnsignedGossipMessage_free(self); }
4137 UnsignedGossipMessage& operator=(UnsignedGossipMessage&& o) { UnsignedGossipMessage_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedGossipMessage)); return *this; }
4138 LDKUnsignedGossipMessage* operator &() { return &self; }
4139 LDKUnsignedGossipMessage* operator ->() { return &self; }
4140 const LDKUnsignedGossipMessage* operator &() const { return &self; }
4141 const LDKUnsignedGossipMessage* operator ->() const { return &self; }
4143 class UnsignedNodeAnnouncement {
4145 LDKUnsignedNodeAnnouncement self;
4147 UnsignedNodeAnnouncement(const UnsignedNodeAnnouncement&) = delete;
4148 UnsignedNodeAnnouncement(UnsignedNodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); }
4149 UnsignedNodeAnnouncement(LDKUnsignedNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedNodeAnnouncement)); }
4150 operator LDKUnsignedNodeAnnouncement() && { LDKUnsignedNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedNodeAnnouncement)); return res; }
4151 ~UnsignedNodeAnnouncement() { UnsignedNodeAnnouncement_free(self); }
4152 UnsignedNodeAnnouncement& operator=(UnsignedNodeAnnouncement&& o) { UnsignedNodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedNodeAnnouncement)); return *this; }
4153 LDKUnsignedNodeAnnouncement* operator &() { return &self; }
4154 LDKUnsignedNodeAnnouncement* operator ->() { return &self; }
4155 const LDKUnsignedNodeAnnouncement* operator &() const { return &self; }
4156 const LDKUnsignedNodeAnnouncement* operator ->() const { return &self; }
4158 class NodeAnnouncement {
4160 LDKNodeAnnouncement self;
4162 NodeAnnouncement(const NodeAnnouncement&) = delete;
4163 NodeAnnouncement(NodeAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(NodeAnnouncement)); }
4164 NodeAnnouncement(LDKNodeAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKNodeAnnouncement)); }
4165 operator LDKNodeAnnouncement() && { LDKNodeAnnouncement res = self; memset(&self, 0, sizeof(LDKNodeAnnouncement)); return res; }
4166 ~NodeAnnouncement() { NodeAnnouncement_free(self); }
4167 NodeAnnouncement& operator=(NodeAnnouncement&& o) { NodeAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(NodeAnnouncement)); return *this; }
4168 LDKNodeAnnouncement* operator &() { return &self; }
4169 LDKNodeAnnouncement* operator ->() { return &self; }
4170 const LDKNodeAnnouncement* operator &() const { return &self; }
4171 const LDKNodeAnnouncement* operator ->() const { return &self; }
4173 class UnsignedChannelAnnouncement {
4175 LDKUnsignedChannelAnnouncement self;
4177 UnsignedChannelAnnouncement(const UnsignedChannelAnnouncement&) = delete;
4178 UnsignedChannelAnnouncement(UnsignedChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); }
4179 UnsignedChannelAnnouncement(LDKUnsignedChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelAnnouncement)); }
4180 operator LDKUnsignedChannelAnnouncement() && { LDKUnsignedChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKUnsignedChannelAnnouncement)); return res; }
4181 ~UnsignedChannelAnnouncement() { UnsignedChannelAnnouncement_free(self); }
4182 UnsignedChannelAnnouncement& operator=(UnsignedChannelAnnouncement&& o) { UnsignedChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelAnnouncement)); return *this; }
4183 LDKUnsignedChannelAnnouncement* operator &() { return &self; }
4184 LDKUnsignedChannelAnnouncement* operator ->() { return &self; }
4185 const LDKUnsignedChannelAnnouncement* operator &() const { return &self; }
4186 const LDKUnsignedChannelAnnouncement* operator ->() const { return &self; }
4188 class ChannelAnnouncement {
4190 LDKChannelAnnouncement self;
4192 ChannelAnnouncement(const ChannelAnnouncement&) = delete;
4193 ChannelAnnouncement(ChannelAnnouncement&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelAnnouncement)); }
4194 ChannelAnnouncement(LDKChannelAnnouncement&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelAnnouncement)); }
4195 operator LDKChannelAnnouncement() && { LDKChannelAnnouncement res = self; memset(&self, 0, sizeof(LDKChannelAnnouncement)); return res; }
4196 ~ChannelAnnouncement() { ChannelAnnouncement_free(self); }
4197 ChannelAnnouncement& operator=(ChannelAnnouncement&& o) { ChannelAnnouncement_free(self); self = o.self; memset(&o, 0, sizeof(ChannelAnnouncement)); return *this; }
4198 LDKChannelAnnouncement* operator &() { return &self; }
4199 LDKChannelAnnouncement* operator ->() { return &self; }
4200 const LDKChannelAnnouncement* operator &() const { return &self; }
4201 const LDKChannelAnnouncement* operator ->() const { return &self; }
4203 class UnsignedChannelUpdate {
4205 LDKUnsignedChannelUpdate self;
4207 UnsignedChannelUpdate(const UnsignedChannelUpdate&) = delete;
4208 UnsignedChannelUpdate(UnsignedChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(UnsignedChannelUpdate)); }
4209 UnsignedChannelUpdate(LDKUnsignedChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUnsignedChannelUpdate)); }
4210 operator LDKUnsignedChannelUpdate() && { LDKUnsignedChannelUpdate res = self; memset(&self, 0, sizeof(LDKUnsignedChannelUpdate)); return res; }
4211 ~UnsignedChannelUpdate() { UnsignedChannelUpdate_free(self); }
4212 UnsignedChannelUpdate& operator=(UnsignedChannelUpdate&& o) { UnsignedChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(UnsignedChannelUpdate)); return *this; }
4213 LDKUnsignedChannelUpdate* operator &() { return &self; }
4214 LDKUnsignedChannelUpdate* operator ->() { return &self; }
4215 const LDKUnsignedChannelUpdate* operator &() const { return &self; }
4216 const LDKUnsignedChannelUpdate* operator ->() const { return &self; }
4218 class ChannelUpdate {
4220 LDKChannelUpdate self;
4222 ChannelUpdate(const ChannelUpdate&) = delete;
4223 ChannelUpdate(ChannelUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelUpdate)); }
4224 ChannelUpdate(LDKChannelUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelUpdate)); }
4225 operator LDKChannelUpdate() && { LDKChannelUpdate res = self; memset(&self, 0, sizeof(LDKChannelUpdate)); return res; }
4226 ~ChannelUpdate() { ChannelUpdate_free(self); }
4227 ChannelUpdate& operator=(ChannelUpdate&& o) { ChannelUpdate_free(self); self = o.self; memset(&o, 0, sizeof(ChannelUpdate)); return *this; }
4228 LDKChannelUpdate* operator &() { return &self; }
4229 LDKChannelUpdate* operator ->() { return &self; }
4230 const LDKChannelUpdate* operator &() const { return &self; }
4231 const LDKChannelUpdate* operator ->() const { return &self; }
4233 class QueryChannelRange {
4235 LDKQueryChannelRange self;
4237 QueryChannelRange(const QueryChannelRange&) = delete;
4238 QueryChannelRange(QueryChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(QueryChannelRange)); }
4239 QueryChannelRange(LDKQueryChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryChannelRange)); }
4240 operator LDKQueryChannelRange() && { LDKQueryChannelRange res = self; memset(&self, 0, sizeof(LDKQueryChannelRange)); return res; }
4241 ~QueryChannelRange() { QueryChannelRange_free(self); }
4242 QueryChannelRange& operator=(QueryChannelRange&& o) { QueryChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(QueryChannelRange)); return *this; }
4243 LDKQueryChannelRange* operator &() { return &self; }
4244 LDKQueryChannelRange* operator ->() { return &self; }
4245 const LDKQueryChannelRange* operator &() const { return &self; }
4246 const LDKQueryChannelRange* operator ->() const { return &self; }
4248 class ReplyChannelRange {
4250 LDKReplyChannelRange self;
4252 ReplyChannelRange(const ReplyChannelRange&) = delete;
4253 ReplyChannelRange(ReplyChannelRange&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyChannelRange)); }
4254 ReplyChannelRange(LDKReplyChannelRange&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyChannelRange)); }
4255 operator LDKReplyChannelRange() && { LDKReplyChannelRange res = self; memset(&self, 0, sizeof(LDKReplyChannelRange)); return res; }
4256 ~ReplyChannelRange() { ReplyChannelRange_free(self); }
4257 ReplyChannelRange& operator=(ReplyChannelRange&& o) { ReplyChannelRange_free(self); self = o.self; memset(&o, 0, sizeof(ReplyChannelRange)); return *this; }
4258 LDKReplyChannelRange* operator &() { return &self; }
4259 LDKReplyChannelRange* operator ->() { return &self; }
4260 const LDKReplyChannelRange* operator &() const { return &self; }
4261 const LDKReplyChannelRange* operator ->() const { return &self; }
4263 class QueryShortChannelIds {
4265 LDKQueryShortChannelIds self;
4267 QueryShortChannelIds(const QueryShortChannelIds&) = delete;
4268 QueryShortChannelIds(QueryShortChannelIds&& o) : self(o.self) { memset(&o, 0, sizeof(QueryShortChannelIds)); }
4269 QueryShortChannelIds(LDKQueryShortChannelIds&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKQueryShortChannelIds)); }
4270 operator LDKQueryShortChannelIds() && { LDKQueryShortChannelIds res = self; memset(&self, 0, sizeof(LDKQueryShortChannelIds)); return res; }
4271 ~QueryShortChannelIds() { QueryShortChannelIds_free(self); }
4272 QueryShortChannelIds& operator=(QueryShortChannelIds&& o) { QueryShortChannelIds_free(self); self = o.self; memset(&o, 0, sizeof(QueryShortChannelIds)); return *this; }
4273 LDKQueryShortChannelIds* operator &() { return &self; }
4274 LDKQueryShortChannelIds* operator ->() { return &self; }
4275 const LDKQueryShortChannelIds* operator &() const { return &self; }
4276 const LDKQueryShortChannelIds* operator ->() const { return &self; }
4278 class ReplyShortChannelIdsEnd {
4280 LDKReplyShortChannelIdsEnd self;
4282 ReplyShortChannelIdsEnd(const ReplyShortChannelIdsEnd&) = delete;
4283 ReplyShortChannelIdsEnd(ReplyShortChannelIdsEnd&& o) : self(o.self) { memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); }
4284 ReplyShortChannelIdsEnd(LDKReplyShortChannelIdsEnd&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReplyShortChannelIdsEnd)); }
4285 operator LDKReplyShortChannelIdsEnd() && { LDKReplyShortChannelIdsEnd res = self; memset(&self, 0, sizeof(LDKReplyShortChannelIdsEnd)); return res; }
4286 ~ReplyShortChannelIdsEnd() { ReplyShortChannelIdsEnd_free(self); }
4287 ReplyShortChannelIdsEnd& operator=(ReplyShortChannelIdsEnd&& o) { ReplyShortChannelIdsEnd_free(self); self = o.self; memset(&o, 0, sizeof(ReplyShortChannelIdsEnd)); return *this; }
4288 LDKReplyShortChannelIdsEnd* operator &() { return &self; }
4289 LDKReplyShortChannelIdsEnd* operator ->() { return &self; }
4290 const LDKReplyShortChannelIdsEnd* operator &() const { return &self; }
4291 const LDKReplyShortChannelIdsEnd* operator ->() const { return &self; }
4293 class GossipTimestampFilter {
4295 LDKGossipTimestampFilter self;
4297 GossipTimestampFilter(const GossipTimestampFilter&) = delete;
4298 GossipTimestampFilter(GossipTimestampFilter&& o) : self(o.self) { memset(&o, 0, sizeof(GossipTimestampFilter)); }
4299 GossipTimestampFilter(LDKGossipTimestampFilter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKGossipTimestampFilter)); }
4300 operator LDKGossipTimestampFilter() && { LDKGossipTimestampFilter res = self; memset(&self, 0, sizeof(LDKGossipTimestampFilter)); return res; }
4301 ~GossipTimestampFilter() { GossipTimestampFilter_free(self); }
4302 GossipTimestampFilter& operator=(GossipTimestampFilter&& o) { GossipTimestampFilter_free(self); self = o.self; memset(&o, 0, sizeof(GossipTimestampFilter)); return *this; }
4303 LDKGossipTimestampFilter* operator &() { return &self; }
4304 LDKGossipTimestampFilter* operator ->() { return &self; }
4305 const LDKGossipTimestampFilter* operator &() const { return &self; }
4306 const LDKGossipTimestampFilter* operator ->() const { return &self; }
4310 LDKErrorAction self;
4312 ErrorAction(const ErrorAction&) = delete;
4313 ErrorAction(ErrorAction&& o) : self(o.self) { memset(&o, 0, sizeof(ErrorAction)); }
4314 ErrorAction(LDKErrorAction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErrorAction)); }
4315 operator LDKErrorAction() && { LDKErrorAction res = self; memset(&self, 0, sizeof(LDKErrorAction)); return res; }
4316 ~ErrorAction() { ErrorAction_free(self); }
4317 ErrorAction& operator=(ErrorAction&& o) { ErrorAction_free(self); self = o.self; memset(&o, 0, sizeof(ErrorAction)); return *this; }
4318 LDKErrorAction* operator &() { return &self; }
4319 LDKErrorAction* operator ->() { return &self; }
4320 const LDKErrorAction* operator &() const { return &self; }
4321 const LDKErrorAction* operator ->() const { return &self; }
4323 class LightningError {
4325 LDKLightningError self;
4327 LightningError(const LightningError&) = delete;
4328 LightningError(LightningError&& o) : self(o.self) { memset(&o, 0, sizeof(LightningError)); }
4329 LightningError(LDKLightningError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLightningError)); }
4330 operator LDKLightningError() && { LDKLightningError res = self; memset(&self, 0, sizeof(LDKLightningError)); return res; }
4331 ~LightningError() { LightningError_free(self); }
4332 LightningError& operator=(LightningError&& o) { LightningError_free(self); self = o.self; memset(&o, 0, sizeof(LightningError)); return *this; }
4333 LDKLightningError* operator &() { return &self; }
4334 LDKLightningError* operator ->() { return &self; }
4335 const LDKLightningError* operator &() const { return &self; }
4336 const LDKLightningError* operator ->() const { return &self; }
4338 class CommitmentUpdate {
4340 LDKCommitmentUpdate self;
4342 CommitmentUpdate(const CommitmentUpdate&) = delete;
4343 CommitmentUpdate(CommitmentUpdate&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentUpdate)); }
4344 CommitmentUpdate(LDKCommitmentUpdate&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentUpdate)); }
4345 operator LDKCommitmentUpdate() && { LDKCommitmentUpdate res = self; memset(&self, 0, sizeof(LDKCommitmentUpdate)); return res; }
4346 ~CommitmentUpdate() { CommitmentUpdate_free(self); }
4347 CommitmentUpdate& operator=(CommitmentUpdate&& o) { CommitmentUpdate_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentUpdate)); return *this; }
4348 LDKCommitmentUpdate* operator &() { return &self; }
4349 LDKCommitmentUpdate* operator ->() { return &self; }
4350 const LDKCommitmentUpdate* operator &() const { return &self; }
4351 const LDKCommitmentUpdate* operator ->() const { return &self; }
4353 class ChannelMessageHandler {
4355 LDKChannelMessageHandler self;
4357 ChannelMessageHandler(const ChannelMessageHandler&) = delete;
4358 ChannelMessageHandler(ChannelMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelMessageHandler)); }
4359 ChannelMessageHandler(LDKChannelMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelMessageHandler)); }
4360 operator LDKChannelMessageHandler() && { LDKChannelMessageHandler res = self; memset(&self, 0, sizeof(LDKChannelMessageHandler)); return res; }
4361 ~ChannelMessageHandler() { ChannelMessageHandler_free(self); }
4362 ChannelMessageHandler& operator=(ChannelMessageHandler&& o) { ChannelMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(ChannelMessageHandler)); return *this; }
4363 LDKChannelMessageHandler* operator &() { return &self; }
4364 LDKChannelMessageHandler* operator ->() { return &self; }
4365 const LDKChannelMessageHandler* operator &() const { return &self; }
4366 const LDKChannelMessageHandler* operator ->() const { return &self; }
4368 * Handle an incoming `open_channel` message from the given peer.
4370 inline void handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg);
4372 * Handle an incoming `open_channel2` message from the given peer.
4374 inline void handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg);
4376 * Handle an incoming `accept_channel` message from the given peer.
4378 inline void handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg);
4380 * Handle an incoming `accept_channel2` message from the given peer.
4382 inline void handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg);
4384 * Handle an incoming `funding_created` message from the given peer.
4386 inline void handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg);
4388 * Handle an incoming `funding_signed` message from the given peer.
4390 inline void handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg);
4392 * Handle an incoming `channel_ready` message from the given peer.
4394 inline void handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg);
4396 * Handle an incoming `shutdown` message from the given peer.
4398 inline void handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg);
4400 * Handle an incoming `closing_signed` message from the given peer.
4402 inline void handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg);
4404 * Handle an incoming `stfu` message from the given peer.
4406 inline void handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg);
4408 * Handle an incoming `splice` message from the given peer.
4410 inline void handle_splice(struct LDKPublicKey their_node_id, const struct LDKSplice *NONNULL_PTR msg);
4412 * Handle an incoming `splice_ack` message from the given peer.
4414 inline void handle_splice_ack(struct LDKPublicKey their_node_id, const struct LDKSpliceAck *NONNULL_PTR msg);
4416 * Handle an incoming `splice_locked` message from the given peer.
4418 inline void handle_splice_locked(struct LDKPublicKey their_node_id, const struct LDKSpliceLocked *NONNULL_PTR msg);
4420 * Handle an incoming `tx_add_input message` from the given peer.
4422 inline void handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg);
4424 * Handle an incoming `tx_add_output` message from the given peer.
4426 inline void handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg);
4428 * Handle an incoming `tx_remove_input` message from the given peer.
4430 inline void handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg);
4432 * Handle an incoming `tx_remove_output` message from the given peer.
4434 inline void handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg);
4436 * Handle an incoming `tx_complete message` from the given peer.
4438 inline void handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg);
4440 * Handle an incoming `tx_signatures` message from the given peer.
4442 inline void handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg);
4444 * Handle an incoming `tx_init_rbf` message from the given peer.
4446 inline void handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg);
4448 * Handle an incoming `tx_ack_rbf` message from the given peer.
4450 inline void handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg);
4452 * Handle an incoming `tx_abort message` from the given peer.
4454 inline void handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg);
4456 * Handle an incoming `update_add_htlc` message from the given peer.
4458 inline void handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg);
4460 * Handle an incoming `update_fulfill_htlc` message from the given peer.
4462 inline void handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg);
4464 * Handle an incoming `update_fail_htlc` message from the given peer.
4466 inline void handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg);
4468 * Handle an incoming `update_fail_malformed_htlc` message from the given peer.
4470 inline void handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg);
4472 * Handle an incoming `commitment_signed` message from the given peer.
4474 inline void handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg);
4476 * Handle an incoming `revoke_and_ack` message from the given peer.
4478 inline void handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg);
4480 * Handle an incoming `update_fee` message from the given peer.
4482 inline void handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg);
4484 * Handle an incoming `announcement_signatures` message from the given peer.
4486 inline void handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg);
4488 * Indicates a connection to the peer failed/an existing connection was lost.
4490 inline void peer_disconnected(struct LDKPublicKey their_node_id);
4492 * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
4494 * May return an `Err(())` if the features the peer supports are not sufficient to communicate
4495 * with us. Implementors should be somewhat conservative about doing so, however, as other
4496 * message handlers may still wish to communicate with this peer.
4498 inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound);
4500 * Handle an incoming `channel_reestablish` message from the given peer.
4502 inline void handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg);
4504 * Handle an incoming `channel_update` message from the given peer.
4506 inline void handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg);
4508 * Handle an incoming `error` message from the given peer.
4510 inline void handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg);
4512 * Gets the node feature flags which this handler itself supports. All available handlers are
4513 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4514 * which are broadcasted in our [`NodeAnnouncement`] message.
4516 inline LDK::NodeFeatures provided_node_features();
4518 * Gets the init feature flags which should be sent to the given peer. All available handlers
4519 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4520 * which are sent in our [`Init`] message.
4522 * Note that this method is called before [`Self::peer_connected`].
4524 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4526 * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
4528 * If it's `None`, then no particular network chain hash compatibility will be enforced when
4529 * connecting to peers.
4531 inline LDK::COption_CVec_ThirtyTwoBytesZZ get_chain_hashes();
4533 class RoutingMessageHandler {
4535 LDKRoutingMessageHandler self;
4537 RoutingMessageHandler(const RoutingMessageHandler&) = delete;
4538 RoutingMessageHandler(RoutingMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(RoutingMessageHandler)); }
4539 RoutingMessageHandler(LDKRoutingMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRoutingMessageHandler)); }
4540 operator LDKRoutingMessageHandler() && { LDKRoutingMessageHandler res = self; memset(&self, 0, sizeof(LDKRoutingMessageHandler)); return res; }
4541 ~RoutingMessageHandler() { RoutingMessageHandler_free(self); }
4542 RoutingMessageHandler& operator=(RoutingMessageHandler&& o) { RoutingMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(RoutingMessageHandler)); return *this; }
4543 LDKRoutingMessageHandler* operator &() { return &self; }
4544 LDKRoutingMessageHandler* operator ->() { return &self; }
4545 const LDKRoutingMessageHandler* operator &() const { return &self; }
4546 const LDKRoutingMessageHandler* operator ->() const { return &self; }
4548 * Handle an incoming `node_announcement` message, returning `true` if it should be forwarded on,
4549 * `false` or returning an `Err` otherwise.
4551 inline LDK::CResult_boolLightningErrorZ handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg);
4553 * Handle a `channel_announcement` message, returning `true` if it should be forwarded on, `false`
4554 * or returning an `Err` otherwise.
4556 inline LDK::CResult_boolLightningErrorZ handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg);
4558 * Handle an incoming `channel_update` message, returning true if it should be forwarded on,
4559 * `false` or returning an `Err` otherwise.
4561 inline LDK::CResult_boolLightningErrorZ handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg);
4563 * Gets channel announcements and updates required to dump our routing table to a remote node,
4564 * starting at the `short_channel_id` indicated by `starting_point` and including announcements
4565 * for a single channel.
4567 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement(uint64_t starting_point);
4569 * Gets a node announcement required to dump our routing table to a remote node, starting at
4570 * the node *after* the provided pubkey and including up to one announcement immediately
4571 * higher (as defined by `<PublicKey as Ord>::cmp`) than `starting_point`.
4572 * If `None` is provided for `starting_point`, we start at the first node.
4574 * Note that starting_point (or a relevant inner pointer) may be NULL or all-0s to represent None
4575 * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4577 inline LDK::NodeAnnouncement get_next_node_announcement(struct LDKNodeId starting_point);
4579 * Called when a connection is established with a peer. This can be used to
4580 * perform routing table synchronization using a strategy defined by the
4583 * May return an `Err(())` if the features the peer supports are not sufficient to communicate
4584 * with us. Implementors should be somewhat conservative about doing so, however, as other
4585 * message handlers may still wish to communicate with this peer.
4587 inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4589 * Handles the reply of a query we initiated to learn about channels
4590 * for a given range of blocks. We can expect to receive one or more
4591 * replies to a single query.
4593 inline LDK::CResult_NoneLightningErrorZ handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg);
4595 * Handles the reply of a query we initiated asking for routing gossip
4596 * messages for a list of channels. We should receive this message when
4597 * a node has completed its best effort to send us the pertaining routing
4600 inline LDK::CResult_NoneLightningErrorZ handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg);
4602 * Handles when a peer asks us to send a list of `short_channel_id`s
4603 * for the requested range of blocks.
4605 inline LDK::CResult_NoneLightningErrorZ handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg);
4607 * Handles when a peer asks us to send routing gossip messages for a
4608 * list of `short_channel_id`s.
4610 inline LDK::CResult_NoneLightningErrorZ handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg);
4612 * Indicates that there are a large number of [`ChannelAnnouncement`] (or other) messages
4613 * pending some async action. While there is no guarantee of the rate of future messages, the
4614 * caller should seek to reduce the rate of new gossip messages handled, especially
4615 * [`ChannelAnnouncement`]s.
4617 inline bool processing_queue_high();
4619 * Gets the node feature flags which this handler itself supports. All available handlers are
4620 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4621 * which are broadcasted in our [`NodeAnnouncement`] message.
4623 inline LDK::NodeFeatures provided_node_features();
4625 * Gets the init feature flags which should be sent to the given peer. All available handlers
4626 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4627 * which are sent in our [`Init`] message.
4629 * Note that this method is called before [`Self::peer_connected`].
4631 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4633 class OnionMessageHandler {
4635 LDKOnionMessageHandler self;
4637 OnionMessageHandler(const OnionMessageHandler&) = delete;
4638 OnionMessageHandler(OnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageHandler)); }
4639 OnionMessageHandler(LDKOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageHandler)); }
4640 operator LDKOnionMessageHandler() && { LDKOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKOnionMessageHandler)); return res; }
4641 ~OnionMessageHandler() { OnionMessageHandler_free(self); }
4642 OnionMessageHandler& operator=(OnionMessageHandler&& o) { OnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageHandler)); return *this; }
4643 LDKOnionMessageHandler* operator &() { return &self; }
4644 LDKOnionMessageHandler* operator ->() { return &self; }
4645 const LDKOnionMessageHandler* operator &() const { return &self; }
4646 const LDKOnionMessageHandler* operator ->() const { return &self; }
4648 * Because much of the lightning network does not yet support forwarding onion messages, we
4649 * may need to directly connect to a node which will forward a message for us. In such a case,
4650 * this method will return the set of nodes which need connection by node_id and the
4651 * corresponding socket addresses where they may accept incoming connections.
4653 * Thus, this method should be polled regularly to detect messages await such a direct
4656 inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ get_and_clear_connections_needed();
4658 * Handle an incoming `onion_message` message from the given peer.
4660 inline void handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg);
4662 * Returns the next pending onion message for the peer with the given node id.
4664 * Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None
4666 inline LDK::OnionMessage next_onion_message_for_peer(struct LDKPublicKey peer_node_id);
4668 * Called when a connection is established with a peer. Can be used to track which peers
4669 * advertise onion message support and are online.
4671 * May return an `Err(())` if the features the peer supports are not sufficient to communicate
4672 * with us. Implementors should be somewhat conservative about doing so, however, as other
4673 * message handlers may still wish to communicate with this peer.
4675 inline LDK::CResult_NoneNoneZ peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound);
4677 * Indicates a connection to the peer failed/an existing connection was lost. Allows handlers to
4678 * drop and refuse to forward onion messages to this peer.
4680 inline void peer_disconnected(struct LDKPublicKey their_node_id);
4682 * Performs actions that should happen roughly every ten seconds after startup. Allows handlers
4683 * to drop any buffered onion messages intended for prospective peers.
4685 inline void timer_tick_occurred();
4687 * Gets the node feature flags which this handler itself supports. All available handlers are
4688 * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
4689 * which are broadcasted in our [`NodeAnnouncement`] message.
4691 inline LDK::NodeFeatures provided_node_features();
4693 * Gets the init feature flags which should be sent to the given peer. All available handlers
4694 * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
4695 * which are sent in our [`Init`] message.
4697 * Note that this method is called before [`Self::peer_connected`].
4699 inline LDK::InitFeatures provided_init_features(struct LDKPublicKey their_node_id);
4701 class FinalOnionHopData {
4703 LDKFinalOnionHopData self;
4705 FinalOnionHopData(const FinalOnionHopData&) = delete;
4706 FinalOnionHopData(FinalOnionHopData&& o) : self(o.self) { memset(&o, 0, sizeof(FinalOnionHopData)); }
4707 FinalOnionHopData(LDKFinalOnionHopData&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFinalOnionHopData)); }
4708 operator LDKFinalOnionHopData() && { LDKFinalOnionHopData res = self; memset(&self, 0, sizeof(LDKFinalOnionHopData)); return res; }
4709 ~FinalOnionHopData() { FinalOnionHopData_free(self); }
4710 FinalOnionHopData& operator=(FinalOnionHopData&& o) { FinalOnionHopData_free(self); self = o.self; memset(&o, 0, sizeof(FinalOnionHopData)); return *this; }
4711 LDKFinalOnionHopData* operator &() { return &self; }
4712 LDKFinalOnionHopData* operator ->() { return &self; }
4713 const LDKFinalOnionHopData* operator &() const { return &self; }
4714 const LDKFinalOnionHopData* operator ->() const { return &self; }
4718 LDKOnionPacket self;
4720 OnionPacket(const OnionPacket&) = delete;
4721 OnionPacket(OnionPacket&& o) : self(o.self) { memset(&o, 0, sizeof(OnionPacket)); }
4722 OnionPacket(LDKOnionPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionPacket)); }
4723 operator LDKOnionPacket() && { LDKOnionPacket res = self; memset(&self, 0, sizeof(LDKOnionPacket)); return res; }
4724 ~OnionPacket() { OnionPacket_free(self); }
4725 OnionPacket& operator=(OnionPacket&& o) { OnionPacket_free(self); self = o.self; memset(&o, 0, sizeof(OnionPacket)); return *this; }
4726 LDKOnionPacket* operator &() { return &self; }
4727 LDKOnionPacket* operator ->() { return &self; }
4728 const LDKOnionPacket* operator &() const { return &self; }
4729 const LDKOnionPacket* operator ->() const { return &self; }
4735 Level(const Level&) = delete;
4736 Level(Level&& o) : self(o.self) { memset(&o, 0, sizeof(Level)); }
4737 Level(LDKLevel&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLevel)); }
4738 operator LDKLevel() && { LDKLevel res = self; memset(&self, 0, sizeof(LDKLevel)); return res; }
4739 Level& operator=(Level&& o) { self = o.self; memset(&o, 0, sizeof(Level)); return *this; }
4740 LDKLevel* operator &() { return &self; }
4741 LDKLevel* operator ->() { return &self; }
4742 const LDKLevel* operator &() const { return &self; }
4743 const LDKLevel* operator ->() const { return &self; }
4749 Record(const Record&) = delete;
4750 Record(Record&& o) : self(o.self) { memset(&o, 0, sizeof(Record)); }
4751 Record(LDKRecord&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRecord)); }
4752 operator LDKRecord() && { LDKRecord res = self; memset(&self, 0, sizeof(LDKRecord)); return res; }
4753 ~Record() { Record_free(self); }
4754 Record& operator=(Record&& o) { Record_free(self); self = o.self; memset(&o, 0, sizeof(Record)); return *this; }
4755 LDKRecord* operator &() { return &self; }
4756 LDKRecord* operator ->() { return &self; }
4757 const LDKRecord* operator &() const { return &self; }
4758 const LDKRecord* operator ->() const { return &self; }
4764 Logger(const Logger&) = delete;
4765 Logger(Logger&& o) : self(o.self) { memset(&o, 0, sizeof(Logger)); }
4766 Logger(LDKLogger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLogger)); }
4767 operator LDKLogger() && { LDKLogger res = self; memset(&self, 0, sizeof(LDKLogger)); return res; }
4768 ~Logger() { Logger_free(self); }
4769 Logger& operator=(Logger&& o) { Logger_free(self); self = o.self; memset(&o, 0, sizeof(Logger)); return *this; }
4770 LDKLogger* operator &() { return &self; }
4771 LDKLogger* operator ->() { return &self; }
4772 const LDKLogger* operator &() const { return &self; }
4773 const LDKLogger* operator ->() const { return &self; }
4775 * Logs the [`Record`].
4777 inline void log(struct LDKRecord record);
4779 class FutureCallback {
4781 LDKFutureCallback self;
4783 FutureCallback(const FutureCallback&) = delete;
4784 FutureCallback(FutureCallback&& o) : self(o.self) { memset(&o, 0, sizeof(FutureCallback)); }
4785 FutureCallback(LDKFutureCallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFutureCallback)); }
4786 operator LDKFutureCallback() && { LDKFutureCallback res = self; memset(&self, 0, sizeof(LDKFutureCallback)); return res; }
4787 ~FutureCallback() { FutureCallback_free(self); }
4788 FutureCallback& operator=(FutureCallback&& o) { FutureCallback_free(self); self = o.self; memset(&o, 0, sizeof(FutureCallback)); return *this; }
4789 LDKFutureCallback* operator &() { return &self; }
4790 LDKFutureCallback* operator ->() { return &self; }
4791 const LDKFutureCallback* operator &() const { return &self; }
4792 const LDKFutureCallback* operator ->() const { return &self; }
4794 * The method which is called.
4802 Future(const Future&) = delete;
4803 Future(Future&& o) : self(o.self) { memset(&o, 0, sizeof(Future)); }
4804 Future(LDKFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFuture)); }
4805 operator LDKFuture() && { LDKFuture res = self; memset(&self, 0, sizeof(LDKFuture)); return res; }
4806 ~Future() { Future_free(self); }
4807 Future& operator=(Future&& o) { Future_free(self); self = o.self; memset(&o, 0, sizeof(Future)); return *this; }
4808 LDKFuture* operator &() { return &self; }
4809 LDKFuture* operator ->() { return &self; }
4810 const LDKFuture* operator &() const { return &self; }
4811 const LDKFuture* operator ->() const { return &self; }
4817 Sleeper(const Sleeper&) = delete;
4818 Sleeper(Sleeper&& o) : self(o.self) { memset(&o, 0, sizeof(Sleeper)); }
4819 Sleeper(LDKSleeper&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSleeper)); }
4820 operator LDKSleeper() && { LDKSleeper res = self; memset(&self, 0, sizeof(LDKSleeper)); return res; }
4821 ~Sleeper() { Sleeper_free(self); }
4822 Sleeper& operator=(Sleeper&& o) { Sleeper_free(self); self = o.self; memset(&o, 0, sizeof(Sleeper)); return *this; }
4823 LDKSleeper* operator &() { return &self; }
4824 LDKSleeper* operator ->() { return &self; }
4825 const LDKSleeper* operator &() const { return &self; }
4826 const LDKSleeper* operator ->() const { return &self; }
4828 class OffersMessageHandler {
4830 LDKOffersMessageHandler self;
4832 OffersMessageHandler(const OffersMessageHandler&) = delete;
4833 OffersMessageHandler(OffersMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessageHandler)); }
4834 OffersMessageHandler(LDKOffersMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessageHandler)); }
4835 operator LDKOffersMessageHandler() && { LDKOffersMessageHandler res = self; memset(&self, 0, sizeof(LDKOffersMessageHandler)); return res; }
4836 ~OffersMessageHandler() { OffersMessageHandler_free(self); }
4837 OffersMessageHandler& operator=(OffersMessageHandler&& o) { OffersMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessageHandler)); return *this; }
4838 LDKOffersMessageHandler* operator &() { return &self; }
4839 LDKOffersMessageHandler* operator ->() { return &self; }
4840 const LDKOffersMessageHandler* operator &() const { return &self; }
4841 const LDKOffersMessageHandler* operator ->() const { return &self; }
4843 * Handles the given message by either responding with an [`Bolt12Invoice`], sending a payment,
4844 * or replying with an error.
4846 * The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
4848 * [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
4850 inline LDK::COption_OffersMessageZ handle_message(struct LDKOffersMessage message);
4852 * Releases any [`OffersMessage`]s that need to be sent.
4854 * Typically, this is used for messages initiating a payment flow rather than in response to
4855 * another message. The latter should use the return value of [`Self::handle_message`].
4857 inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ release_pending_messages();
4859 class OffersMessage {
4861 LDKOffersMessage self;
4863 OffersMessage(const OffersMessage&) = delete;
4864 OffersMessage(OffersMessage&& o) : self(o.self) { memset(&o, 0, sizeof(OffersMessage)); }
4865 OffersMessage(LDKOffersMessage&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOffersMessage)); }
4866 operator LDKOffersMessage() && { LDKOffersMessage res = self; memset(&self, 0, sizeof(LDKOffersMessage)); return res; }
4867 ~OffersMessage() { OffersMessage_free(self); }
4868 OffersMessage& operator=(OffersMessage&& o) { OffersMessage_free(self); self = o.self; memset(&o, 0, sizeof(OffersMessage)); return *this; }
4869 LDKOffersMessage* operator &() { return &self; }
4870 LDKOffersMessage* operator ->() { return &self; }
4871 const LDKOffersMessage* operator &() const { return &self; }
4872 const LDKOffersMessage* operator ->() const { return &self; }
4878 HTLCClaim(const HTLCClaim&) = delete;
4879 HTLCClaim(HTLCClaim&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCClaim)); }
4880 HTLCClaim(LDKHTLCClaim&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCClaim)); }
4881 operator LDKHTLCClaim() && { LDKHTLCClaim res = self; memset(&self, 0, sizeof(LDKHTLCClaim)); return res; }
4882 HTLCClaim& operator=(HTLCClaim&& o) { self = o.self; memset(&o, 0, sizeof(HTLCClaim)); return *this; }
4883 LDKHTLCClaim* operator &() { return &self; }
4884 LDKHTLCClaim* operator ->() { return &self; }
4885 const LDKHTLCClaim* operator &() const { return &self; }
4886 const LDKHTLCClaim* operator ->() const { return &self; }
4888 class CounterpartyCommitmentSecrets {
4890 LDKCounterpartyCommitmentSecrets self;
4892 CounterpartyCommitmentSecrets(const CounterpartyCommitmentSecrets&) = delete;
4893 CounterpartyCommitmentSecrets(CounterpartyCommitmentSecrets&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); }
4894 CounterpartyCommitmentSecrets(LDKCounterpartyCommitmentSecrets&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); }
4895 operator LDKCounterpartyCommitmentSecrets() && { LDKCounterpartyCommitmentSecrets res = self; memset(&self, 0, sizeof(LDKCounterpartyCommitmentSecrets)); return res; }
4896 ~CounterpartyCommitmentSecrets() { CounterpartyCommitmentSecrets_free(self); }
4897 CounterpartyCommitmentSecrets& operator=(CounterpartyCommitmentSecrets&& o) { CounterpartyCommitmentSecrets_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyCommitmentSecrets)); return *this; }
4898 LDKCounterpartyCommitmentSecrets* operator &() { return &self; }
4899 LDKCounterpartyCommitmentSecrets* operator ->() { return &self; }
4900 const LDKCounterpartyCommitmentSecrets* operator &() const { return &self; }
4901 const LDKCounterpartyCommitmentSecrets* operator ->() const { return &self; }
4903 class TxCreationKeys {
4905 LDKTxCreationKeys self;
4907 TxCreationKeys(const TxCreationKeys&) = delete;
4908 TxCreationKeys(TxCreationKeys&& o) : self(o.self) { memset(&o, 0, sizeof(TxCreationKeys)); }
4909 TxCreationKeys(LDKTxCreationKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTxCreationKeys)); }
4910 operator LDKTxCreationKeys() && { LDKTxCreationKeys res = self; memset(&self, 0, sizeof(LDKTxCreationKeys)); return res; }
4911 ~TxCreationKeys() { TxCreationKeys_free(self); }
4912 TxCreationKeys& operator=(TxCreationKeys&& o) { TxCreationKeys_free(self); self = o.self; memset(&o, 0, sizeof(TxCreationKeys)); return *this; }
4913 LDKTxCreationKeys* operator &() { return &self; }
4914 LDKTxCreationKeys* operator ->() { return &self; }
4915 const LDKTxCreationKeys* operator &() const { return &self; }
4916 const LDKTxCreationKeys* operator ->() const { return &self; }
4918 class ChannelPublicKeys {
4920 LDKChannelPublicKeys self;
4922 ChannelPublicKeys(const ChannelPublicKeys&) = delete;
4923 ChannelPublicKeys(ChannelPublicKeys&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelPublicKeys)); }
4924 ChannelPublicKeys(LDKChannelPublicKeys&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelPublicKeys)); }
4925 operator LDKChannelPublicKeys() && { LDKChannelPublicKeys res = self; memset(&self, 0, sizeof(LDKChannelPublicKeys)); return res; }
4926 ~ChannelPublicKeys() { ChannelPublicKeys_free(self); }
4927 ChannelPublicKeys& operator=(ChannelPublicKeys&& o) { ChannelPublicKeys_free(self); self = o.self; memset(&o, 0, sizeof(ChannelPublicKeys)); return *this; }
4928 LDKChannelPublicKeys* operator &() { return &self; }
4929 LDKChannelPublicKeys* operator ->() { return &self; }
4930 const LDKChannelPublicKeys* operator &() const { return &self; }
4931 const LDKChannelPublicKeys* operator ->() const { return &self; }
4933 class HTLCOutputInCommitment {
4935 LDKHTLCOutputInCommitment self;
4937 HTLCOutputInCommitment(const HTLCOutputInCommitment&) = delete;
4938 HTLCOutputInCommitment(HTLCOutputInCommitment&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCOutputInCommitment)); }
4939 HTLCOutputInCommitment(LDKHTLCOutputInCommitment&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCOutputInCommitment)); }
4940 operator LDKHTLCOutputInCommitment() && { LDKHTLCOutputInCommitment res = self; memset(&self, 0, sizeof(LDKHTLCOutputInCommitment)); return res; }
4941 ~HTLCOutputInCommitment() { HTLCOutputInCommitment_free(self); }
4942 HTLCOutputInCommitment& operator=(HTLCOutputInCommitment&& o) { HTLCOutputInCommitment_free(self); self = o.self; memset(&o, 0, sizeof(HTLCOutputInCommitment)); return *this; }
4943 LDKHTLCOutputInCommitment* operator &() { return &self; }
4944 LDKHTLCOutputInCommitment* operator ->() { return &self; }
4945 const LDKHTLCOutputInCommitment* operator &() const { return &self; }
4946 const LDKHTLCOutputInCommitment* operator ->() const { return &self; }
4948 class ChannelTransactionParameters {
4950 LDKChannelTransactionParameters self;
4952 ChannelTransactionParameters(const ChannelTransactionParameters&) = delete;
4953 ChannelTransactionParameters(ChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(ChannelTransactionParameters)); }
4954 ChannelTransactionParameters(LDKChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChannelTransactionParameters)); }
4955 operator LDKChannelTransactionParameters() && { LDKChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKChannelTransactionParameters)); return res; }
4956 ~ChannelTransactionParameters() { ChannelTransactionParameters_free(self); }
4957 ChannelTransactionParameters& operator=(ChannelTransactionParameters&& o) { ChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(ChannelTransactionParameters)); return *this; }
4958 LDKChannelTransactionParameters* operator &() { return &self; }
4959 LDKChannelTransactionParameters* operator ->() { return &self; }
4960 const LDKChannelTransactionParameters* operator &() const { return &self; }
4961 const LDKChannelTransactionParameters* operator ->() const { return &self; }
4963 class CounterpartyChannelTransactionParameters {
4965 LDKCounterpartyChannelTransactionParameters self;
4967 CounterpartyChannelTransactionParameters(const CounterpartyChannelTransactionParameters&) = delete;
4968 CounterpartyChannelTransactionParameters(CounterpartyChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); }
4969 CounterpartyChannelTransactionParameters(LDKCounterpartyChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); }
4970 operator LDKCounterpartyChannelTransactionParameters() && { LDKCounterpartyChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKCounterpartyChannelTransactionParameters)); return res; }
4971 ~CounterpartyChannelTransactionParameters() { CounterpartyChannelTransactionParameters_free(self); }
4972 CounterpartyChannelTransactionParameters& operator=(CounterpartyChannelTransactionParameters&& o) { CounterpartyChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(CounterpartyChannelTransactionParameters)); return *this; }
4973 LDKCounterpartyChannelTransactionParameters* operator &() { return &self; }
4974 LDKCounterpartyChannelTransactionParameters* operator ->() { return &self; }
4975 const LDKCounterpartyChannelTransactionParameters* operator &() const { return &self; }
4976 const LDKCounterpartyChannelTransactionParameters* operator ->() const { return &self; }
4978 class DirectedChannelTransactionParameters {
4980 LDKDirectedChannelTransactionParameters self;
4982 DirectedChannelTransactionParameters(const DirectedChannelTransactionParameters&) = delete;
4983 DirectedChannelTransactionParameters(DirectedChannelTransactionParameters&& o) : self(o.self) { memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); }
4984 DirectedChannelTransactionParameters(LDKDirectedChannelTransactionParameters&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDirectedChannelTransactionParameters)); }
4985 operator LDKDirectedChannelTransactionParameters() && { LDKDirectedChannelTransactionParameters res = self; memset(&self, 0, sizeof(LDKDirectedChannelTransactionParameters)); return res; }
4986 ~DirectedChannelTransactionParameters() { DirectedChannelTransactionParameters_free(self); }
4987 DirectedChannelTransactionParameters& operator=(DirectedChannelTransactionParameters&& o) { DirectedChannelTransactionParameters_free(self); self = o.self; memset(&o, 0, sizeof(DirectedChannelTransactionParameters)); return *this; }
4988 LDKDirectedChannelTransactionParameters* operator &() { return &self; }
4989 LDKDirectedChannelTransactionParameters* operator ->() { return &self; }
4990 const LDKDirectedChannelTransactionParameters* operator &() const { return &self; }
4991 const LDKDirectedChannelTransactionParameters* operator ->() const { return &self; }
4993 class HolderCommitmentTransaction {
4995 LDKHolderCommitmentTransaction self;
4997 HolderCommitmentTransaction(const HolderCommitmentTransaction&) = delete;
4998 HolderCommitmentTransaction(HolderCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(HolderCommitmentTransaction)); }
4999 HolderCommitmentTransaction(LDKHolderCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHolderCommitmentTransaction)); }
5000 operator LDKHolderCommitmentTransaction() && { LDKHolderCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKHolderCommitmentTransaction)); return res; }
5001 ~HolderCommitmentTransaction() { HolderCommitmentTransaction_free(self); }
5002 HolderCommitmentTransaction& operator=(HolderCommitmentTransaction&& o) { HolderCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(HolderCommitmentTransaction)); return *this; }
5003 LDKHolderCommitmentTransaction* operator &() { return &self; }
5004 LDKHolderCommitmentTransaction* operator ->() { return &self; }
5005 const LDKHolderCommitmentTransaction* operator &() const { return &self; }
5006 const LDKHolderCommitmentTransaction* operator ->() const { return &self; }
5008 class BuiltCommitmentTransaction {
5010 LDKBuiltCommitmentTransaction self;
5012 BuiltCommitmentTransaction(const BuiltCommitmentTransaction&) = delete;
5013 BuiltCommitmentTransaction(BuiltCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(BuiltCommitmentTransaction)); }
5014 BuiltCommitmentTransaction(LDKBuiltCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBuiltCommitmentTransaction)); }
5015 operator LDKBuiltCommitmentTransaction() && { LDKBuiltCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKBuiltCommitmentTransaction)); return res; }
5016 ~BuiltCommitmentTransaction() { BuiltCommitmentTransaction_free(self); }
5017 BuiltCommitmentTransaction& operator=(BuiltCommitmentTransaction&& o) { BuiltCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(BuiltCommitmentTransaction)); return *this; }
5018 LDKBuiltCommitmentTransaction* operator &() { return &self; }
5019 LDKBuiltCommitmentTransaction* operator ->() { return &self; }
5020 const LDKBuiltCommitmentTransaction* operator &() const { return &self; }
5021 const LDKBuiltCommitmentTransaction* operator ->() const { return &self; }
5023 class ClosingTransaction {
5025 LDKClosingTransaction self;
5027 ClosingTransaction(const ClosingTransaction&) = delete;
5028 ClosingTransaction(ClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(ClosingTransaction)); }
5029 ClosingTransaction(LDKClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosingTransaction)); }
5030 operator LDKClosingTransaction() && { LDKClosingTransaction res = self; memset(&self, 0, sizeof(LDKClosingTransaction)); return res; }
5031 ~ClosingTransaction() { ClosingTransaction_free(self); }
5032 ClosingTransaction& operator=(ClosingTransaction&& o) { ClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(ClosingTransaction)); return *this; }
5033 LDKClosingTransaction* operator &() { return &self; }
5034 LDKClosingTransaction* operator ->() { return &self; }
5035 const LDKClosingTransaction* operator &() const { return &self; }
5036 const LDKClosingTransaction* operator ->() const { return &self; }
5038 class TrustedClosingTransaction {
5040 LDKTrustedClosingTransaction self;
5042 TrustedClosingTransaction(const TrustedClosingTransaction&) = delete;
5043 TrustedClosingTransaction(TrustedClosingTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedClosingTransaction)); }
5044 TrustedClosingTransaction(LDKTrustedClosingTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedClosingTransaction)); }
5045 operator LDKTrustedClosingTransaction() && { LDKTrustedClosingTransaction res = self; memset(&self, 0, sizeof(LDKTrustedClosingTransaction)); return res; }
5046 ~TrustedClosingTransaction() { TrustedClosingTransaction_free(self); }
5047 TrustedClosingTransaction& operator=(TrustedClosingTransaction&& o) { TrustedClosingTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedClosingTransaction)); return *this; }
5048 LDKTrustedClosingTransaction* operator &() { return &self; }
5049 LDKTrustedClosingTransaction* operator ->() { return &self; }
5050 const LDKTrustedClosingTransaction* operator &() const { return &self; }
5051 const LDKTrustedClosingTransaction* operator ->() const { return &self; }
5053 class CommitmentTransaction {
5055 LDKCommitmentTransaction self;
5057 CommitmentTransaction(const CommitmentTransaction&) = delete;
5058 CommitmentTransaction(CommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(CommitmentTransaction)); }
5059 CommitmentTransaction(LDKCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCommitmentTransaction)); }
5060 operator LDKCommitmentTransaction() && { LDKCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKCommitmentTransaction)); return res; }
5061 ~CommitmentTransaction() { CommitmentTransaction_free(self); }
5062 CommitmentTransaction& operator=(CommitmentTransaction&& o) { CommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(CommitmentTransaction)); return *this; }
5063 LDKCommitmentTransaction* operator &() { return &self; }
5064 LDKCommitmentTransaction* operator ->() { return &self; }
5065 const LDKCommitmentTransaction* operator &() const { return &self; }
5066 const LDKCommitmentTransaction* operator ->() const { return &self; }
5068 class TrustedCommitmentTransaction {
5070 LDKTrustedCommitmentTransaction self;
5072 TrustedCommitmentTransaction(const TrustedCommitmentTransaction&) = delete;
5073 TrustedCommitmentTransaction(TrustedCommitmentTransaction&& o) : self(o.self) { memset(&o, 0, sizeof(TrustedCommitmentTransaction)); }
5074 TrustedCommitmentTransaction(LDKTrustedCommitmentTransaction&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTrustedCommitmentTransaction)); }
5075 operator LDKTrustedCommitmentTransaction() && { LDKTrustedCommitmentTransaction res = self; memset(&self, 0, sizeof(LDKTrustedCommitmentTransaction)); return res; }
5076 ~TrustedCommitmentTransaction() { TrustedCommitmentTransaction_free(self); }
5077 TrustedCommitmentTransaction& operator=(TrustedCommitmentTransaction&& o) { TrustedCommitmentTransaction_free(self); self = o.self; memset(&o, 0, sizeof(TrustedCommitmentTransaction)); return *this; }
5078 LDKTrustedCommitmentTransaction* operator &() { return &self; }
5079 LDKTrustedCommitmentTransaction* operator ->() { return &self; }
5080 const LDKTrustedCommitmentTransaction* operator &() const { return &self; }
5081 const LDKTrustedCommitmentTransaction* operator ->() const { return &self; }
5083 class ShutdownScript {
5085 LDKShutdownScript self;
5087 ShutdownScript(const ShutdownScript&) = delete;
5088 ShutdownScript(ShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(ShutdownScript)); }
5089 ShutdownScript(LDKShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKShutdownScript)); }
5090 operator LDKShutdownScript() && { LDKShutdownScript res = self; memset(&self, 0, sizeof(LDKShutdownScript)); return res; }
5091 ~ShutdownScript() { ShutdownScript_free(self); }
5092 ShutdownScript& operator=(ShutdownScript&& o) { ShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(ShutdownScript)); return *this; }
5093 LDKShutdownScript* operator &() { return &self; }
5094 LDKShutdownScript* operator ->() { return &self; }
5095 const LDKShutdownScript* operator &() const { return &self; }
5096 const LDKShutdownScript* operator ->() const { return &self; }
5098 class InvalidShutdownScript {
5100 LDKInvalidShutdownScript self;
5102 InvalidShutdownScript(const InvalidShutdownScript&) = delete;
5103 InvalidShutdownScript(InvalidShutdownScript&& o) : self(o.self) { memset(&o, 0, sizeof(InvalidShutdownScript)); }
5104 InvalidShutdownScript(LDKInvalidShutdownScript&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvalidShutdownScript)); }
5105 operator LDKInvalidShutdownScript() && { LDKInvalidShutdownScript res = self; memset(&self, 0, sizeof(LDKInvalidShutdownScript)); return res; }
5106 ~InvalidShutdownScript() { InvalidShutdownScript_free(self); }
5107 InvalidShutdownScript& operator=(InvalidShutdownScript&& o) { InvalidShutdownScript_free(self); self = o.self; memset(&o, 0, sizeof(InvalidShutdownScript)); return *this; }
5108 LDKInvalidShutdownScript* operator &() { return &self; }
5109 LDKInvalidShutdownScript* operator ->() { return &self; }
5110 const LDKInvalidShutdownScript* operator &() const { return &self; }
5111 const LDKInvalidShutdownScript* operator ->() const { return &self; }
5113 class Bolt12ParseError {
5115 LDKBolt12ParseError self;
5117 Bolt12ParseError(const Bolt12ParseError&) = delete;
5118 Bolt12ParseError(Bolt12ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12ParseError)); }
5119 Bolt12ParseError(LDKBolt12ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12ParseError)); }
5120 operator LDKBolt12ParseError() && { LDKBolt12ParseError res = self; memset(&self, 0, sizeof(LDKBolt12ParseError)); return res; }
5121 ~Bolt12ParseError() { Bolt12ParseError_free(self); }
5122 Bolt12ParseError& operator=(Bolt12ParseError&& o) { Bolt12ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt12ParseError)); return *this; }
5123 LDKBolt12ParseError* operator &() { return &self; }
5124 LDKBolt12ParseError* operator ->() { return &self; }
5125 const LDKBolt12ParseError* operator &() const { return &self; }
5126 const LDKBolt12ParseError* operator ->() const { return &self; }
5128 class Bolt12SemanticError {
5130 LDKBolt12SemanticError self;
5132 Bolt12SemanticError(const Bolt12SemanticError&) = delete;
5133 Bolt12SemanticError(Bolt12SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt12SemanticError)); }
5134 Bolt12SemanticError(LDKBolt12SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt12SemanticError)); }
5135 operator LDKBolt12SemanticError() && { LDKBolt12SemanticError res = self; memset(&self, 0, sizeof(LDKBolt12SemanticError)); return res; }
5136 Bolt12SemanticError& operator=(Bolt12SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt12SemanticError)); return *this; }
5137 LDKBolt12SemanticError* operator &() { return &self; }
5138 LDKBolt12SemanticError* operator ->() { return &self; }
5139 const LDKBolt12SemanticError* operator &() const { return &self; }
5140 const LDKBolt12SemanticError* operator ->() const { return &self; }
5142 class BroadcasterInterface {
5144 LDKBroadcasterInterface self;
5146 BroadcasterInterface(const BroadcasterInterface&) = delete;
5147 BroadcasterInterface(BroadcasterInterface&& o) : self(o.self) { memset(&o, 0, sizeof(BroadcasterInterface)); }
5148 BroadcasterInterface(LDKBroadcasterInterface&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBroadcasterInterface)); }
5149 operator LDKBroadcasterInterface() && { LDKBroadcasterInterface res = self; memset(&self, 0, sizeof(LDKBroadcasterInterface)); return res; }
5150 ~BroadcasterInterface() { BroadcasterInterface_free(self); }
5151 BroadcasterInterface& operator=(BroadcasterInterface&& o) { BroadcasterInterface_free(self); self = o.self; memset(&o, 0, sizeof(BroadcasterInterface)); return *this; }
5152 LDKBroadcasterInterface* operator &() { return &self; }
5153 LDKBroadcasterInterface* operator ->() { return &self; }
5154 const LDKBroadcasterInterface* operator &() const { return &self; }
5155 const LDKBroadcasterInterface* operator ->() const { return &self; }
5157 * Sends a list of transactions out to (hopefully) be mined.
5158 * This only needs to handle the actual broadcasting of transactions, LDK will automatically
5159 * rebroadcast transactions that haven't made it into a block.
5161 * In some cases LDK may attempt to broadcast a transaction which double-spends another
5162 * and this isn't a bug and can be safely ignored.
5164 * If more than one transaction is given, these transactions should be considered to be a
5165 * package and broadcast together. Some of the transactions may or may not depend on each other,
5166 * be sure to manage both cases correctly.
5168 * Bitcoin transaction packages are defined in BIP 331 and here:
5169 * <https://github.com/bitcoin/bitcoin/blob/master/doc/policy/packages.md>
5171 inline void broadcast_transactions(struct LDKCVec_TransactionZ txs);
5173 class ConfirmationTarget {
5175 LDKConfirmationTarget self;
5177 ConfirmationTarget(const ConfirmationTarget&) = delete;
5178 ConfirmationTarget(ConfirmationTarget&& o) : self(o.self) { memset(&o, 0, sizeof(ConfirmationTarget)); }
5179 ConfirmationTarget(LDKConfirmationTarget&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKConfirmationTarget)); }
5180 operator LDKConfirmationTarget() && { LDKConfirmationTarget res = self; memset(&self, 0, sizeof(LDKConfirmationTarget)); return res; }
5181 ConfirmationTarget& operator=(ConfirmationTarget&& o) { self = o.self; memset(&o, 0, sizeof(ConfirmationTarget)); return *this; }
5182 LDKConfirmationTarget* operator &() { return &self; }
5183 LDKConfirmationTarget* operator ->() { return &self; }
5184 const LDKConfirmationTarget* operator &() const { return &self; }
5185 const LDKConfirmationTarget* operator ->() const { return &self; }
5187 class FeeEstimator {
5189 LDKFeeEstimator self;
5191 FeeEstimator(const FeeEstimator&) = delete;
5192 FeeEstimator(FeeEstimator&& o) : self(o.self) { memset(&o, 0, sizeof(FeeEstimator)); }
5193 FeeEstimator(LDKFeeEstimator&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFeeEstimator)); }
5194 operator LDKFeeEstimator() && { LDKFeeEstimator res = self; memset(&self, 0, sizeof(LDKFeeEstimator)); return res; }
5195 ~FeeEstimator() { FeeEstimator_free(self); }
5196 FeeEstimator& operator=(FeeEstimator&& o) { FeeEstimator_free(self); self = o.self; memset(&o, 0, sizeof(FeeEstimator)); return *this; }
5197 LDKFeeEstimator* operator &() { return &self; }
5198 LDKFeeEstimator* operator ->() { return &self; }
5199 const LDKFeeEstimator* operator &() const { return &self; }
5200 const LDKFeeEstimator* operator ->() const { return &self; }
5202 * Gets estimated satoshis of fee required per 1000 Weight-Units.
5204 * LDK will wrap this method and ensure that the value returned is no smaller than 253
5205 * (ie 1 satoshi-per-byte rounded up to ensure later round-downs don't put us below 1 satoshi-per-byte).
5207 * The following unit conversions can be used to convert to sats/KW:
5208 * * satoshis-per-byte * 250
5209 * * satoshis-per-kbyte / 4
5211 inline uint32_t get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target);
5217 Packet(const Packet&) = delete;
5218 Packet(Packet&& o) : self(o.self) { memset(&o, 0, sizeof(Packet)); }
5219 Packet(LDKPacket&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPacket)); }
5220 operator LDKPacket() && { LDKPacket res = self; memset(&self, 0, sizeof(LDKPacket)); return res; }
5221 ~Packet() { Packet_free(self); }
5222 Packet& operator=(Packet&& o) { Packet_free(self); self = o.self; memset(&o, 0, sizeof(Packet)); return *this; }
5223 LDKPacket* operator &() { return &self; }
5224 LDKPacket* operator ->() { return &self; }
5225 const LDKPacket* operator &() const { return &self; }
5226 const LDKPacket* operator ->() const { return &self; }
5228 class ParsedOnionMessageContents {
5230 LDKParsedOnionMessageContents self;
5232 ParsedOnionMessageContents(const ParsedOnionMessageContents&) = delete;
5233 ParsedOnionMessageContents(ParsedOnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(ParsedOnionMessageContents)); }
5234 ParsedOnionMessageContents(LDKParsedOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParsedOnionMessageContents)); }
5235 operator LDKParsedOnionMessageContents() && { LDKParsedOnionMessageContents res = self; memset(&self, 0, sizeof(LDKParsedOnionMessageContents)); return res; }
5236 ~ParsedOnionMessageContents() { ParsedOnionMessageContents_free(self); }
5237 ParsedOnionMessageContents& operator=(ParsedOnionMessageContents&& o) { ParsedOnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(ParsedOnionMessageContents)); return *this; }
5238 LDKParsedOnionMessageContents* operator &() { return &self; }
5239 LDKParsedOnionMessageContents* operator ->() { return &self; }
5240 const LDKParsedOnionMessageContents* operator &() const { return &self; }
5241 const LDKParsedOnionMessageContents* operator ->() const { return &self; }
5243 class OnionMessageContents {
5245 LDKOnionMessageContents self;
5247 OnionMessageContents(const OnionMessageContents&) = delete;
5248 OnionMessageContents(OnionMessageContents&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessageContents)); }
5249 OnionMessageContents(LDKOnionMessageContents&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessageContents)); }
5250 operator LDKOnionMessageContents() && { LDKOnionMessageContents res = self; memset(&self, 0, sizeof(LDKOnionMessageContents)); return res; }
5251 ~OnionMessageContents() { OnionMessageContents_free(self); }
5252 OnionMessageContents& operator=(OnionMessageContents&& o) { OnionMessageContents_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessageContents)); return *this; }
5253 LDKOnionMessageContents* operator &() { return &self; }
5254 LDKOnionMessageContents* operator ->() { return &self; }
5255 const LDKOnionMessageContents* operator &() const { return &self; }
5256 const LDKOnionMessageContents* operator ->() const { return &self; }
5258 * Returns the TLV type identifying the message contents. MUST be >= 64.
5260 inline uint64_t tlv_type();
5262 * Return a human-readable "debug" string describing this object
5264 inline LDK::Str debug_str();
5266 class PaymentPurpose {
5268 LDKPaymentPurpose self;
5270 PaymentPurpose(const PaymentPurpose&) = delete;
5271 PaymentPurpose(PaymentPurpose&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentPurpose)); }
5272 PaymentPurpose(LDKPaymentPurpose&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentPurpose)); }
5273 operator LDKPaymentPurpose() && { LDKPaymentPurpose res = self; memset(&self, 0, sizeof(LDKPaymentPurpose)); return res; }
5274 ~PaymentPurpose() { PaymentPurpose_free(self); }
5275 PaymentPurpose& operator=(PaymentPurpose&& o) { PaymentPurpose_free(self); self = o.self; memset(&o, 0, sizeof(PaymentPurpose)); return *this; }
5276 LDKPaymentPurpose* operator &() { return &self; }
5277 LDKPaymentPurpose* operator ->() { return &self; }
5278 const LDKPaymentPurpose* operator &() const { return &self; }
5279 const LDKPaymentPurpose* operator ->() const { return &self; }
5283 LDKClaimedHTLC self;
5285 ClaimedHTLC(const ClaimedHTLC&) = delete;
5286 ClaimedHTLC(ClaimedHTLC&& o) : self(o.self) { memset(&o, 0, sizeof(ClaimedHTLC)); }
5287 ClaimedHTLC(LDKClaimedHTLC&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClaimedHTLC)); }
5288 operator LDKClaimedHTLC() && { LDKClaimedHTLC res = self; memset(&self, 0, sizeof(LDKClaimedHTLC)); return res; }
5289 ~ClaimedHTLC() { ClaimedHTLC_free(self); }
5290 ClaimedHTLC& operator=(ClaimedHTLC&& o) { ClaimedHTLC_free(self); self = o.self; memset(&o, 0, sizeof(ClaimedHTLC)); return *this; }
5291 LDKClaimedHTLC* operator &() { return &self; }
5292 LDKClaimedHTLC* operator ->() { return &self; }
5293 const LDKClaimedHTLC* operator &() const { return &self; }
5294 const LDKClaimedHTLC* operator ->() const { return &self; }
5298 LDKPathFailure self;
5300 PathFailure(const PathFailure&) = delete;
5301 PathFailure(PathFailure&& o) : self(o.self) { memset(&o, 0, sizeof(PathFailure)); }
5302 PathFailure(LDKPathFailure&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPathFailure)); }
5303 operator LDKPathFailure() && { LDKPathFailure res = self; memset(&self, 0, sizeof(LDKPathFailure)); return res; }
5304 ~PathFailure() { PathFailure_free(self); }
5305 PathFailure& operator=(PathFailure&& o) { PathFailure_free(self); self = o.self; memset(&o, 0, sizeof(PathFailure)); return *this; }
5306 LDKPathFailure* operator &() { return &self; }
5307 LDKPathFailure* operator ->() { return &self; }
5308 const LDKPathFailure* operator &() const { return &self; }
5309 const LDKPathFailure* operator ->() const { return &self; }
5311 class ClosureReason {
5313 LDKClosureReason self;
5315 ClosureReason(const ClosureReason&) = delete;
5316 ClosureReason(ClosureReason&& o) : self(o.self) { memset(&o, 0, sizeof(ClosureReason)); }
5317 ClosureReason(LDKClosureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKClosureReason)); }
5318 operator LDKClosureReason() && { LDKClosureReason res = self; memset(&self, 0, sizeof(LDKClosureReason)); return res; }
5319 ~ClosureReason() { ClosureReason_free(self); }
5320 ClosureReason& operator=(ClosureReason&& o) { ClosureReason_free(self); self = o.self; memset(&o, 0, sizeof(ClosureReason)); return *this; }
5321 LDKClosureReason* operator &() { return &self; }
5322 LDKClosureReason* operator ->() { return &self; }
5323 const LDKClosureReason* operator &() const { return &self; }
5324 const LDKClosureReason* operator ->() const { return &self; }
5326 class HTLCDestination {
5328 LDKHTLCDestination self;
5330 HTLCDestination(const HTLCDestination&) = delete;
5331 HTLCDestination(HTLCDestination&& o) : self(o.self) { memset(&o, 0, sizeof(HTLCDestination)); }
5332 HTLCDestination(LDKHTLCDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHTLCDestination)); }
5333 operator LDKHTLCDestination() && { LDKHTLCDestination res = self; memset(&self, 0, sizeof(LDKHTLCDestination)); return res; }
5334 ~HTLCDestination() { HTLCDestination_free(self); }
5335 HTLCDestination& operator=(HTLCDestination&& o) { HTLCDestination_free(self); self = o.self; memset(&o, 0, sizeof(HTLCDestination)); return *this; }
5336 LDKHTLCDestination* operator &() { return &self; }
5337 LDKHTLCDestination* operator ->() { return &self; }
5338 const LDKHTLCDestination* operator &() const { return &self; }
5339 const LDKHTLCDestination* operator ->() const { return &self; }
5341 class PaymentFailureReason {
5343 LDKPaymentFailureReason self;
5345 PaymentFailureReason(const PaymentFailureReason&) = delete;
5346 PaymentFailureReason(PaymentFailureReason&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentFailureReason)); }
5347 PaymentFailureReason(LDKPaymentFailureReason&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentFailureReason)); }
5348 operator LDKPaymentFailureReason() && { LDKPaymentFailureReason res = self; memset(&self, 0, sizeof(LDKPaymentFailureReason)); return res; }
5349 PaymentFailureReason& operator=(PaymentFailureReason&& o) { self = o.self; memset(&o, 0, sizeof(PaymentFailureReason)); return *this; }
5350 LDKPaymentFailureReason* operator &() { return &self; }
5351 LDKPaymentFailureReason* operator ->() { return &self; }
5352 const LDKPaymentFailureReason* operator &() const { return &self; }
5353 const LDKPaymentFailureReason* operator ->() const { return &self; }
5359 Event(const Event&) = delete;
5360 Event(Event&& o) : self(o.self) { memset(&o, 0, sizeof(Event)); }
5361 Event(LDKEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEvent)); }
5362 operator LDKEvent() && { LDKEvent res = self; memset(&self, 0, sizeof(LDKEvent)); return res; }
5363 ~Event() { Event_free(self); }
5364 Event& operator=(Event&& o) { Event_free(self); self = o.self; memset(&o, 0, sizeof(Event)); return *this; }
5365 LDKEvent* operator &() { return &self; }
5366 LDKEvent* operator ->() { return &self; }
5367 const LDKEvent* operator &() const { return &self; }
5368 const LDKEvent* operator ->() const { return &self; }
5370 class MessageSendEvent {
5372 LDKMessageSendEvent self;
5374 MessageSendEvent(const MessageSendEvent&) = delete;
5375 MessageSendEvent(MessageSendEvent&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEvent)); }
5376 MessageSendEvent(LDKMessageSendEvent&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEvent)); }
5377 operator LDKMessageSendEvent() && { LDKMessageSendEvent res = self; memset(&self, 0, sizeof(LDKMessageSendEvent)); return res; }
5378 ~MessageSendEvent() { MessageSendEvent_free(self); }
5379 MessageSendEvent& operator=(MessageSendEvent&& o) { MessageSendEvent_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEvent)); return *this; }
5380 LDKMessageSendEvent* operator &() { return &self; }
5381 LDKMessageSendEvent* operator ->() { return &self; }
5382 const LDKMessageSendEvent* operator &() const { return &self; }
5383 const LDKMessageSendEvent* operator ->() const { return &self; }
5385 class MessageSendEventsProvider {
5387 LDKMessageSendEventsProvider self;
5389 MessageSendEventsProvider(const MessageSendEventsProvider&) = delete;
5390 MessageSendEventsProvider(MessageSendEventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(MessageSendEventsProvider)); }
5391 MessageSendEventsProvider(LDKMessageSendEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageSendEventsProvider)); }
5392 operator LDKMessageSendEventsProvider() && { LDKMessageSendEventsProvider res = self; memset(&self, 0, sizeof(LDKMessageSendEventsProvider)); return res; }
5393 ~MessageSendEventsProvider() { MessageSendEventsProvider_free(self); }
5394 MessageSendEventsProvider& operator=(MessageSendEventsProvider&& o) { MessageSendEventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(MessageSendEventsProvider)); return *this; }
5395 LDKMessageSendEventsProvider* operator &() { return &self; }
5396 LDKMessageSendEventsProvider* operator ->() { return &self; }
5397 const LDKMessageSendEventsProvider* operator &() const { return &self; }
5398 const LDKMessageSendEventsProvider* operator ->() const { return &self; }
5400 * Gets the list of pending events which were generated by previous actions, clearing the list
5403 inline LDK::CVec_MessageSendEventZ get_and_clear_pending_msg_events();
5405 class EventsProvider {
5407 LDKEventsProvider self;
5409 EventsProvider(const EventsProvider&) = delete;
5410 EventsProvider(EventsProvider&& o) : self(o.self) { memset(&o, 0, sizeof(EventsProvider)); }
5411 EventsProvider(LDKEventsProvider&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventsProvider)); }
5412 operator LDKEventsProvider() && { LDKEventsProvider res = self; memset(&self, 0, sizeof(LDKEventsProvider)); return res; }
5413 ~EventsProvider() { EventsProvider_free(self); }
5414 EventsProvider& operator=(EventsProvider&& o) { EventsProvider_free(self); self = o.self; memset(&o, 0, sizeof(EventsProvider)); return *this; }
5415 LDKEventsProvider* operator &() { return &self; }
5416 LDKEventsProvider* operator ->() { return &self; }
5417 const LDKEventsProvider* operator &() const { return &self; }
5418 const LDKEventsProvider* operator ->() const { return &self; }
5420 * Processes any events generated since the last call using the given event handler.
5422 * See the trait-level documentation for requirements.
5424 inline void process_pending_events(struct LDKEventHandler handler);
5426 class EventHandler {
5428 LDKEventHandler self;
5430 EventHandler(const EventHandler&) = delete;
5431 EventHandler(EventHandler&& o) : self(o.self) { memset(&o, 0, sizeof(EventHandler)); }
5432 EventHandler(LDKEventHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKEventHandler)); }
5433 operator LDKEventHandler() && { LDKEventHandler res = self; memset(&self, 0, sizeof(LDKEventHandler)); return res; }
5434 ~EventHandler() { EventHandler_free(self); }
5435 EventHandler& operator=(EventHandler&& o) { EventHandler_free(self); self = o.self; memset(&o, 0, sizeof(EventHandler)); return *this; }
5436 LDKEventHandler* operator &() { return &self; }
5437 LDKEventHandler* operator ->() { return &self; }
5438 const LDKEventHandler* operator &() const { return &self; }
5439 const LDKEventHandler* operator ->() const { return &self; }
5441 * Handles the given [`Event`].
5443 * See [`EventsProvider`] for details that must be considered when implementing this method.
5445 inline void handle_event(struct LDKEvent event);
5447 class Bolt11ParseError {
5449 LDKBolt11ParseError self;
5451 Bolt11ParseError(const Bolt11ParseError&) = delete;
5452 Bolt11ParseError(Bolt11ParseError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11ParseError)); }
5453 Bolt11ParseError(LDKBolt11ParseError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11ParseError)); }
5454 operator LDKBolt11ParseError() && { LDKBolt11ParseError res = self; memset(&self, 0, sizeof(LDKBolt11ParseError)); return res; }
5455 ~Bolt11ParseError() { Bolt11ParseError_free(self); }
5456 Bolt11ParseError& operator=(Bolt11ParseError&& o) { Bolt11ParseError_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11ParseError)); return *this; }
5457 LDKBolt11ParseError* operator &() { return &self; }
5458 LDKBolt11ParseError* operator ->() { return &self; }
5459 const LDKBolt11ParseError* operator &() const { return &self; }
5460 const LDKBolt11ParseError* operator ->() const { return &self; }
5462 class ParseOrSemanticError {
5464 LDKParseOrSemanticError self;
5466 ParseOrSemanticError(const ParseOrSemanticError&) = delete;
5467 ParseOrSemanticError(ParseOrSemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(ParseOrSemanticError)); }
5468 ParseOrSemanticError(LDKParseOrSemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKParseOrSemanticError)); }
5469 operator LDKParseOrSemanticError() && { LDKParseOrSemanticError res = self; memset(&self, 0, sizeof(LDKParseOrSemanticError)); return res; }
5470 ~ParseOrSemanticError() { ParseOrSemanticError_free(self); }
5471 ParseOrSemanticError& operator=(ParseOrSemanticError&& o) { ParseOrSemanticError_free(self); self = o.self; memset(&o, 0, sizeof(ParseOrSemanticError)); return *this; }
5472 LDKParseOrSemanticError* operator &() { return &self; }
5473 LDKParseOrSemanticError* operator ->() { return &self; }
5474 const LDKParseOrSemanticError* operator &() const { return &self; }
5475 const LDKParseOrSemanticError* operator ->() const { return &self; }
5477 class Bolt11Invoice {
5479 LDKBolt11Invoice self;
5481 Bolt11Invoice(const Bolt11Invoice&) = delete;
5482 Bolt11Invoice(Bolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11Invoice)); }
5483 Bolt11Invoice(LDKBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11Invoice)); }
5484 operator LDKBolt11Invoice() && { LDKBolt11Invoice res = self; memset(&self, 0, sizeof(LDKBolt11Invoice)); return res; }
5485 ~Bolt11Invoice() { Bolt11Invoice_free(self); }
5486 Bolt11Invoice& operator=(Bolt11Invoice&& o) { Bolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11Invoice)); return *this; }
5487 LDKBolt11Invoice* operator &() { return &self; }
5488 LDKBolt11Invoice* operator ->() { return &self; }
5489 const LDKBolt11Invoice* operator &() const { return &self; }
5490 const LDKBolt11Invoice* operator ->() const { return &self; }
5492 class SignedRawBolt11Invoice {
5494 LDKSignedRawBolt11Invoice self;
5496 SignedRawBolt11Invoice(const SignedRawBolt11Invoice&) = delete;
5497 SignedRawBolt11Invoice(SignedRawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(SignedRawBolt11Invoice)); }
5498 SignedRawBolt11Invoice(LDKSignedRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignedRawBolt11Invoice)); }
5499 operator LDKSignedRawBolt11Invoice() && { LDKSignedRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKSignedRawBolt11Invoice)); return res; }
5500 ~SignedRawBolt11Invoice() { SignedRawBolt11Invoice_free(self); }
5501 SignedRawBolt11Invoice& operator=(SignedRawBolt11Invoice&& o) { SignedRawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(SignedRawBolt11Invoice)); return *this; }
5502 LDKSignedRawBolt11Invoice* operator &() { return &self; }
5503 LDKSignedRawBolt11Invoice* operator ->() { return &self; }
5504 const LDKSignedRawBolt11Invoice* operator &() const { return &self; }
5505 const LDKSignedRawBolt11Invoice* operator ->() const { return &self; }
5507 class RawBolt11Invoice {
5509 LDKRawBolt11Invoice self;
5511 RawBolt11Invoice(const RawBolt11Invoice&) = delete;
5512 RawBolt11Invoice(RawBolt11Invoice&& o) : self(o.self) { memset(&o, 0, sizeof(RawBolt11Invoice)); }
5513 RawBolt11Invoice(LDKRawBolt11Invoice&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawBolt11Invoice)); }
5514 operator LDKRawBolt11Invoice() && { LDKRawBolt11Invoice res = self; memset(&self, 0, sizeof(LDKRawBolt11Invoice)); return res; }
5515 ~RawBolt11Invoice() { RawBolt11Invoice_free(self); }
5516 RawBolt11Invoice& operator=(RawBolt11Invoice&& o) { RawBolt11Invoice_free(self); self = o.self; memset(&o, 0, sizeof(RawBolt11Invoice)); return *this; }
5517 LDKRawBolt11Invoice* operator &() { return &self; }
5518 LDKRawBolt11Invoice* operator ->() { return &self; }
5519 const LDKRawBolt11Invoice* operator &() const { return &self; }
5520 const LDKRawBolt11Invoice* operator ->() const { return &self; }
5524 LDKRawDataPart self;
5526 RawDataPart(const RawDataPart&) = delete;
5527 RawDataPart(RawDataPart&& o) : self(o.self) { memset(&o, 0, sizeof(RawDataPart)); }
5528 RawDataPart(LDKRawDataPart&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRawDataPart)); }
5529 operator LDKRawDataPart() && { LDKRawDataPart res = self; memset(&self, 0, sizeof(LDKRawDataPart)); return res; }
5530 ~RawDataPart() { RawDataPart_free(self); }
5531 RawDataPart& operator=(RawDataPart&& o) { RawDataPart_free(self); self = o.self; memset(&o, 0, sizeof(RawDataPart)); return *this; }
5532 LDKRawDataPart* operator &() { return &self; }
5533 LDKRawDataPart* operator ->() { return &self; }
5534 const LDKRawDataPart* operator &() const { return &self; }
5535 const LDKRawDataPart* operator ->() const { return &self; }
5537 class PositiveTimestamp {
5539 LDKPositiveTimestamp self;
5541 PositiveTimestamp(const PositiveTimestamp&) = delete;
5542 PositiveTimestamp(PositiveTimestamp&& o) : self(o.self) { memset(&o, 0, sizeof(PositiveTimestamp)); }
5543 PositiveTimestamp(LDKPositiveTimestamp&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPositiveTimestamp)); }
5544 operator LDKPositiveTimestamp() && { LDKPositiveTimestamp res = self; memset(&self, 0, sizeof(LDKPositiveTimestamp)); return res; }
5545 ~PositiveTimestamp() { PositiveTimestamp_free(self); }
5546 PositiveTimestamp& operator=(PositiveTimestamp&& o) { PositiveTimestamp_free(self); self = o.self; memset(&o, 0, sizeof(PositiveTimestamp)); return *this; }
5547 LDKPositiveTimestamp* operator &() { return &self; }
5548 LDKPositiveTimestamp* operator ->() { return &self; }
5549 const LDKPositiveTimestamp* operator &() const { return &self; }
5550 const LDKPositiveTimestamp* operator ->() const { return &self; }
5556 SiPrefix(const SiPrefix&) = delete;
5557 SiPrefix(SiPrefix&& o) : self(o.self) { memset(&o, 0, sizeof(SiPrefix)); }
5558 SiPrefix(LDKSiPrefix&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSiPrefix)); }
5559 operator LDKSiPrefix() && { LDKSiPrefix res = self; memset(&self, 0, sizeof(LDKSiPrefix)); return res; }
5560 SiPrefix& operator=(SiPrefix&& o) { self = o.self; memset(&o, 0, sizeof(SiPrefix)); return *this; }
5561 LDKSiPrefix* operator &() { return &self; }
5562 LDKSiPrefix* operator ->() { return &self; }
5563 const LDKSiPrefix* operator &() const { return &self; }
5564 const LDKSiPrefix* operator ->() const { return &self; }
5570 Currency(const Currency&) = delete;
5571 Currency(Currency&& o) : self(o.self) { memset(&o, 0, sizeof(Currency)); }
5572 Currency(LDKCurrency&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCurrency)); }
5573 operator LDKCurrency() && { LDKCurrency res = self; memset(&self, 0, sizeof(LDKCurrency)); return res; }
5574 Currency& operator=(Currency&& o) { self = o.self; memset(&o, 0, sizeof(Currency)); return *this; }
5575 LDKCurrency* operator &() { return &self; }
5576 LDKCurrency* operator ->() { return &self; }
5577 const LDKCurrency* operator &() const { return &self; }
5578 const LDKCurrency* operator ->() const { return &self; }
5584 Sha256(const Sha256&) = delete;
5585 Sha256(Sha256&& o) : self(o.self) { memset(&o, 0, sizeof(Sha256)); }
5586 Sha256(LDKSha256&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSha256)); }
5587 operator LDKSha256() && { LDKSha256 res = self; memset(&self, 0, sizeof(LDKSha256)); return res; }
5588 ~Sha256() { Sha256_free(self); }
5589 Sha256& operator=(Sha256&& o) { Sha256_free(self); self = o.self; memset(&o, 0, sizeof(Sha256)); return *this; }
5590 LDKSha256* operator &() { return &self; }
5591 LDKSha256* operator ->() { return &self; }
5592 const LDKSha256* operator &() const { return &self; }
5593 const LDKSha256* operator ->() const { return &self; }
5597 LDKDescription self;
5599 Description(const Description&) = delete;
5600 Description(Description&& o) : self(o.self) { memset(&o, 0, sizeof(Description)); }
5601 Description(LDKDescription&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDescription)); }
5602 operator LDKDescription() && { LDKDescription res = self; memset(&self, 0, sizeof(LDKDescription)); return res; }
5603 ~Description() { Description_free(self); }
5604 Description& operator=(Description&& o) { Description_free(self); self = o.self; memset(&o, 0, sizeof(Description)); return *this; }
5605 LDKDescription* operator &() { return &self; }
5606 LDKDescription* operator ->() { return &self; }
5607 const LDKDescription* operator &() const { return &self; }
5608 const LDKDescription* operator ->() const { return &self; }
5612 LDKPayeePubKey self;
5614 PayeePubKey(const PayeePubKey&) = delete;
5615 PayeePubKey(PayeePubKey&& o) : self(o.self) { memset(&o, 0, sizeof(PayeePubKey)); }
5616 PayeePubKey(LDKPayeePubKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPayeePubKey)); }
5617 operator LDKPayeePubKey() && { LDKPayeePubKey res = self; memset(&self, 0, sizeof(LDKPayeePubKey)); return res; }
5618 ~PayeePubKey() { PayeePubKey_free(self); }
5619 PayeePubKey& operator=(PayeePubKey&& o) { PayeePubKey_free(self); self = o.self; memset(&o, 0, sizeof(PayeePubKey)); return *this; }
5620 LDKPayeePubKey* operator &() { return &self; }
5621 LDKPayeePubKey* operator ->() { return &self; }
5622 const LDKPayeePubKey* operator &() const { return &self; }
5623 const LDKPayeePubKey* operator ->() const { return &self; }
5629 ExpiryTime(const ExpiryTime&) = delete;
5630 ExpiryTime(ExpiryTime&& o) : self(o.self) { memset(&o, 0, sizeof(ExpiryTime)); }
5631 ExpiryTime(LDKExpiryTime&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKExpiryTime)); }
5632 operator LDKExpiryTime() && { LDKExpiryTime res = self; memset(&self, 0, sizeof(LDKExpiryTime)); return res; }
5633 ~ExpiryTime() { ExpiryTime_free(self); }
5634 ExpiryTime& operator=(ExpiryTime&& o) { ExpiryTime_free(self); self = o.self; memset(&o, 0, sizeof(ExpiryTime)); return *this; }
5635 LDKExpiryTime* operator &() { return &self; }
5636 LDKExpiryTime* operator ->() { return &self; }
5637 const LDKExpiryTime* operator &() const { return &self; }
5638 const LDKExpiryTime* operator ->() const { return &self; }
5640 class MinFinalCltvExpiryDelta {
5642 LDKMinFinalCltvExpiryDelta self;
5644 MinFinalCltvExpiryDelta(const MinFinalCltvExpiryDelta&) = delete;
5645 MinFinalCltvExpiryDelta(MinFinalCltvExpiryDelta&& o) : self(o.self) { memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); }
5646 MinFinalCltvExpiryDelta(LDKMinFinalCltvExpiryDelta&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); }
5647 operator LDKMinFinalCltvExpiryDelta() && { LDKMinFinalCltvExpiryDelta res = self; memset(&self, 0, sizeof(LDKMinFinalCltvExpiryDelta)); return res; }
5648 ~MinFinalCltvExpiryDelta() { MinFinalCltvExpiryDelta_free(self); }
5649 MinFinalCltvExpiryDelta& operator=(MinFinalCltvExpiryDelta&& o) { MinFinalCltvExpiryDelta_free(self); self = o.self; memset(&o, 0, sizeof(MinFinalCltvExpiryDelta)); return *this; }
5650 LDKMinFinalCltvExpiryDelta* operator &() { return &self; }
5651 LDKMinFinalCltvExpiryDelta* operator ->() { return &self; }
5652 const LDKMinFinalCltvExpiryDelta* operator &() const { return &self; }
5653 const LDKMinFinalCltvExpiryDelta* operator ->() const { return &self; }
5659 Fallback(const Fallback&) = delete;
5660 Fallback(Fallback&& o) : self(o.self) { memset(&o, 0, sizeof(Fallback)); }
5661 Fallback(LDKFallback&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFallback)); }
5662 operator LDKFallback() && { LDKFallback res = self; memset(&self, 0, sizeof(LDKFallback)); return res; }
5663 ~Fallback() { Fallback_free(self); }
5664 Fallback& operator=(Fallback&& o) { Fallback_free(self); self = o.self; memset(&o, 0, sizeof(Fallback)); return *this; }
5665 LDKFallback* operator &() { return &self; }
5666 LDKFallback* operator ->() { return &self; }
5667 const LDKFallback* operator &() const { return &self; }
5668 const LDKFallback* operator ->() const { return &self; }
5670 class Bolt11InvoiceSignature {
5672 LDKBolt11InvoiceSignature self;
5674 Bolt11InvoiceSignature(const Bolt11InvoiceSignature&) = delete;
5675 Bolt11InvoiceSignature(Bolt11InvoiceSignature&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11InvoiceSignature)); }
5676 Bolt11InvoiceSignature(LDKBolt11InvoiceSignature&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11InvoiceSignature)); }
5677 operator LDKBolt11InvoiceSignature() && { LDKBolt11InvoiceSignature res = self; memset(&self, 0, sizeof(LDKBolt11InvoiceSignature)); return res; }
5678 ~Bolt11InvoiceSignature() { Bolt11InvoiceSignature_free(self); }
5679 Bolt11InvoiceSignature& operator=(Bolt11InvoiceSignature&& o) { Bolt11InvoiceSignature_free(self); self = o.self; memset(&o, 0, sizeof(Bolt11InvoiceSignature)); return *this; }
5680 LDKBolt11InvoiceSignature* operator &() { return &self; }
5681 LDKBolt11InvoiceSignature* operator ->() { return &self; }
5682 const LDKBolt11InvoiceSignature* operator &() const { return &self; }
5683 const LDKBolt11InvoiceSignature* operator ->() const { return &self; }
5685 class PrivateRoute {
5687 LDKPrivateRoute self;
5689 PrivateRoute(const PrivateRoute&) = delete;
5690 PrivateRoute(PrivateRoute&& o) : self(o.self) { memset(&o, 0, sizeof(PrivateRoute)); }
5691 PrivateRoute(LDKPrivateRoute&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrivateRoute)); }
5692 operator LDKPrivateRoute() && { LDKPrivateRoute res = self; memset(&self, 0, sizeof(LDKPrivateRoute)); return res; }
5693 ~PrivateRoute() { PrivateRoute_free(self); }
5694 PrivateRoute& operator=(PrivateRoute&& o) { PrivateRoute_free(self); self = o.self; memset(&o, 0, sizeof(PrivateRoute)); return *this; }
5695 LDKPrivateRoute* operator &() { return &self; }
5696 LDKPrivateRoute* operator ->() { return &self; }
5697 const LDKPrivateRoute* operator &() const { return &self; }
5698 const LDKPrivateRoute* operator ->() const { return &self; }
5700 class CreationError {
5702 LDKCreationError self;
5704 CreationError(const CreationError&) = delete;
5705 CreationError(CreationError&& o) : self(o.self) { memset(&o, 0, sizeof(CreationError)); }
5706 CreationError(LDKCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCreationError)); }
5707 operator LDKCreationError() && { LDKCreationError res = self; memset(&self, 0, sizeof(LDKCreationError)); return res; }
5708 CreationError& operator=(CreationError&& o) { self = o.self; memset(&o, 0, sizeof(CreationError)); return *this; }
5709 LDKCreationError* operator &() { return &self; }
5710 LDKCreationError* operator ->() { return &self; }
5711 const LDKCreationError* operator &() const { return &self; }
5712 const LDKCreationError* operator ->() const { return &self; }
5714 class Bolt11SemanticError {
5716 LDKBolt11SemanticError self;
5718 Bolt11SemanticError(const Bolt11SemanticError&) = delete;
5719 Bolt11SemanticError(Bolt11SemanticError&& o) : self(o.self) { memset(&o, 0, sizeof(Bolt11SemanticError)); }
5720 Bolt11SemanticError(LDKBolt11SemanticError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBolt11SemanticError)); }
5721 operator LDKBolt11SemanticError() && { LDKBolt11SemanticError res = self; memset(&self, 0, sizeof(LDKBolt11SemanticError)); return res; }
5722 Bolt11SemanticError& operator=(Bolt11SemanticError&& o) { self = o.self; memset(&o, 0, sizeof(Bolt11SemanticError)); return *this; }
5723 LDKBolt11SemanticError* operator &() { return &self; }
5724 LDKBolt11SemanticError* operator ->() { return &self; }
5725 const LDKBolt11SemanticError* operator &() const { return &self; }
5726 const LDKBolt11SemanticError* operator ->() const { return &self; }
5728 class SignOrCreationError {
5730 LDKSignOrCreationError self;
5732 SignOrCreationError(const SignOrCreationError&) = delete;
5733 SignOrCreationError(SignOrCreationError&& o) : self(o.self) { memset(&o, 0, sizeof(SignOrCreationError)); }
5734 SignOrCreationError(LDKSignOrCreationError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSignOrCreationError)); }
5735 operator LDKSignOrCreationError() && { LDKSignOrCreationError res = self; memset(&self, 0, sizeof(LDKSignOrCreationError)); return res; }
5736 ~SignOrCreationError() { SignOrCreationError_free(self); }
5737 SignOrCreationError& operator=(SignOrCreationError&& o) { SignOrCreationError_free(self); self = o.self; memset(&o, 0, sizeof(SignOrCreationError)); return *this; }
5738 LDKSignOrCreationError* operator &() { return &self; }
5739 LDKSignOrCreationError* operator ->() { return &self; }
5740 const LDKSignOrCreationError* operator &() const { return &self; }
5741 const LDKSignOrCreationError* operator ->() const { return &self; }
5747 OutPoint(const OutPoint&) = delete;
5748 OutPoint(OutPoint&& o) : self(o.self) { memset(&o, 0, sizeof(OutPoint)); }
5749 OutPoint(LDKOutPoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOutPoint)); }
5750 operator LDKOutPoint() && { LDKOutPoint res = self; memset(&self, 0, sizeof(LDKOutPoint)); return res; }
5751 ~OutPoint() { OutPoint_free(self); }
5752 OutPoint& operator=(OutPoint&& o) { OutPoint_free(self); self = o.self; memset(&o, 0, sizeof(OutPoint)); return *this; }
5753 LDKOutPoint* operator &() { return &self; }
5754 LDKOutPoint* operator ->() { return &self; }
5755 const LDKOutPoint* operator &() const { return &self; }
5756 const LDKOutPoint* operator ->() const { return &self; }
5762 BigSize(const BigSize&) = delete;
5763 BigSize(BigSize&& o) : self(o.self) { memset(&o, 0, sizeof(BigSize)); }
5764 BigSize(LDKBigSize&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBigSize)); }
5765 operator LDKBigSize() && { LDKBigSize res = self; memset(&self, 0, sizeof(LDKBigSize)); return res; }
5766 ~BigSize() { BigSize_free(self); }
5767 BigSize& operator=(BigSize&& o) { BigSize_free(self); self = o.self; memset(&o, 0, sizeof(BigSize)); return *this; }
5768 LDKBigSize* operator &() { return &self; }
5769 LDKBigSize* operator ->() { return &self; }
5770 const LDKBigSize* operator &() const { return &self; }
5771 const LDKBigSize* operator ->() const { return &self; }
5777 Hostname(const Hostname&) = delete;
5778 Hostname(Hostname&& o) : self(o.self) { memset(&o, 0, sizeof(Hostname)); }
5779 Hostname(LDKHostname&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHostname)); }
5780 operator LDKHostname() && { LDKHostname res = self; memset(&self, 0, sizeof(LDKHostname)); return res; }
5781 ~Hostname() { Hostname_free(self); }
5782 Hostname& operator=(Hostname&& o) { Hostname_free(self); self = o.self; memset(&o, 0, sizeof(Hostname)); return *this; }
5783 LDKHostname* operator &() { return &self; }
5784 LDKHostname* operator ->() { return &self; }
5785 const LDKHostname* operator &() const { return &self; }
5786 const LDKHostname* operator ->() const { return &self; }
5788 class TransactionU16LenLimited {
5790 LDKTransactionU16LenLimited self;
5792 TransactionU16LenLimited(const TransactionU16LenLimited&) = delete;
5793 TransactionU16LenLimited(TransactionU16LenLimited&& o) : self(o.self) { memset(&o, 0, sizeof(TransactionU16LenLimited)); }
5794 TransactionU16LenLimited(LDKTransactionU16LenLimited&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKTransactionU16LenLimited)); }
5795 operator LDKTransactionU16LenLimited() && { LDKTransactionU16LenLimited res = self; memset(&self, 0, sizeof(LDKTransactionU16LenLimited)); return res; }
5796 ~TransactionU16LenLimited() { TransactionU16LenLimited_free(self); }
5797 TransactionU16LenLimited& operator=(TransactionU16LenLimited&& o) { TransactionU16LenLimited_free(self); self = o.self; memset(&o, 0, sizeof(TransactionU16LenLimited)); return *this; }
5798 LDKTransactionU16LenLimited* operator &() { return &self; }
5799 LDKTransactionU16LenLimited* operator ->() { return &self; }
5800 const LDKTransactionU16LenLimited* operator &() const { return &self; }
5801 const LDKTransactionU16LenLimited* operator ->() const { return &self; }
5803 class UntrustedString {
5805 LDKUntrustedString self;
5807 UntrustedString(const UntrustedString&) = delete;
5808 UntrustedString(UntrustedString&& o) : self(o.self) { memset(&o, 0, sizeof(UntrustedString)); }
5809 UntrustedString(LDKUntrustedString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUntrustedString)); }
5810 operator LDKUntrustedString() && { LDKUntrustedString res = self; memset(&self, 0, sizeof(LDKUntrustedString)); return res; }
5811 ~UntrustedString() { UntrustedString_free(self); }
5812 UntrustedString& operator=(UntrustedString&& o) { UntrustedString_free(self); self = o.self; memset(&o, 0, sizeof(UntrustedString)); return *this; }
5813 LDKUntrustedString* operator &() { return &self; }
5814 LDKUntrustedString* operator ->() { return &self; }
5815 const LDKUntrustedString* operator &() const { return &self; }
5816 const LDKUntrustedString* operator ->() const { return &self; }
5818 class PrintableString {
5820 LDKPrintableString self;
5822 PrintableString(const PrintableString&) = delete;
5823 PrintableString(PrintableString&& o) : self(o.self) { memset(&o, 0, sizeof(PrintableString)); }
5824 PrintableString(LDKPrintableString&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPrintableString)); }
5825 operator LDKPrintableString() && { LDKPrintableString res = self; memset(&self, 0, sizeof(LDKPrintableString)); return res; }
5826 ~PrintableString() { PrintableString_free(self); }
5827 PrintableString& operator=(PrintableString&& o) { PrintableString_free(self); self = o.self; memset(&o, 0, sizeof(PrintableString)); return *this; }
5828 LDKPrintableString* operator &() { return &self; }
5829 LDKPrintableString* operator ->() { return &self; }
5830 const LDKPrintableString* operator &() const { return &self; }
5831 const LDKPrintableString* operator ->() const { return &self; }
5833 class CustomMessageReader {
5835 LDKCustomMessageReader self;
5837 CustomMessageReader(const CustomMessageReader&) = delete;
5838 CustomMessageReader(CustomMessageReader&& o) : self(o.self) { memset(&o, 0, sizeof(CustomMessageReader)); }
5839 CustomMessageReader(LDKCustomMessageReader&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomMessageReader)); }
5840 operator LDKCustomMessageReader() && { LDKCustomMessageReader res = self; memset(&self, 0, sizeof(LDKCustomMessageReader)); return res; }
5841 ~CustomMessageReader() { CustomMessageReader_free(self); }
5842 CustomMessageReader& operator=(CustomMessageReader&& o) { CustomMessageReader_free(self); self = o.self; memset(&o, 0, sizeof(CustomMessageReader)); return *this; }
5843 LDKCustomMessageReader* operator &() { return &self; }
5844 LDKCustomMessageReader* operator ->() { return &self; }
5845 const LDKCustomMessageReader* operator &() const { return &self; }
5846 const LDKCustomMessageReader* operator ->() const { return &self; }
5848 * Decodes a custom message to `CustomMessageType`. If the given message type is known to the
5849 * implementation and the message could be decoded, must return `Ok(Some(message))`. If the
5850 * message type is unknown to the implementation, must return `Ok(None)`. If a decoding error
5851 * occur, must return `Err(DecodeError::X)` where `X` details the encountered error.
5853 inline LDK::CResult_COption_TypeZDecodeErrorZ read(uint16_t message_type, struct LDKu8slice buffer);
5859 Type(const Type&) = delete;
5860 Type(Type&& o) : self(o.self) { memset(&o, 0, sizeof(Type)); }
5861 Type(LDKType&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKType)); }
5862 operator LDKType() && { LDKType res = self; memset(&self, 0, sizeof(LDKType)); return res; }
5863 ~Type() { Type_free(self); }
5864 Type& operator=(Type&& o) { Type_free(self); self = o.self; memset(&o, 0, sizeof(Type)); return *this; }
5865 LDKType* operator &() { return &self; }
5866 LDKType* operator ->() { return &self; }
5867 const LDKType* operator &() const { return &self; }
5868 const LDKType* operator ->() const { return &self; }
5870 * Returns the type identifying the message payload.
5872 inline uint16_t type_id();
5874 * Return a human-readable "debug" string describing this object
5876 inline LDK::Str debug_str();
5880 LDKForwardNode self;
5882 ForwardNode(const ForwardNode&) = delete;
5883 ForwardNode(ForwardNode&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardNode)); }
5884 ForwardNode(LDKForwardNode&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardNode)); }
5885 operator LDKForwardNode() && { LDKForwardNode res = self; memset(&self, 0, sizeof(LDKForwardNode)); return res; }
5886 ~ForwardNode() { ForwardNode_free(self); }
5887 ForwardNode& operator=(ForwardNode&& o) { ForwardNode_free(self); self = o.self; memset(&o, 0, sizeof(ForwardNode)); return *this; }
5888 LDKForwardNode* operator &() { return &self; }
5889 LDKForwardNode* operator ->() { return &self; }
5890 const LDKForwardNode* operator &() const { return &self; }
5891 const LDKForwardNode* operator ->() const { return &self; }
5895 LDKForwardTlvs self;
5897 ForwardTlvs(const ForwardTlvs&) = delete;
5898 ForwardTlvs(ForwardTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ForwardTlvs)); }
5899 ForwardTlvs(LDKForwardTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKForwardTlvs)); }
5900 operator LDKForwardTlvs() && { LDKForwardTlvs res = self; memset(&self, 0, sizeof(LDKForwardTlvs)); return res; }
5901 ~ForwardTlvs() { ForwardTlvs_free(self); }
5902 ForwardTlvs& operator=(ForwardTlvs&& o) { ForwardTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ForwardTlvs)); return *this; }
5903 LDKForwardTlvs* operator &() { return &self; }
5904 LDKForwardTlvs* operator ->() { return &self; }
5905 const LDKForwardTlvs* operator &() const { return &self; }
5906 const LDKForwardTlvs* operator ->() const { return &self; }
5910 LDKReceiveTlvs self;
5912 ReceiveTlvs(const ReceiveTlvs&) = delete;
5913 ReceiveTlvs(ReceiveTlvs&& o) : self(o.self) { memset(&o, 0, sizeof(ReceiveTlvs)); }
5914 ReceiveTlvs(LDKReceiveTlvs&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKReceiveTlvs)); }
5915 operator LDKReceiveTlvs() && { LDKReceiveTlvs res = self; memset(&self, 0, sizeof(LDKReceiveTlvs)); return res; }
5916 ~ReceiveTlvs() { ReceiveTlvs_free(self); }
5917 ReceiveTlvs& operator=(ReceiveTlvs&& o) { ReceiveTlvs_free(self); self = o.self; memset(&o, 0, sizeof(ReceiveTlvs)); return *this; }
5918 LDKReceiveTlvs* operator &() { return &self; }
5919 LDKReceiveTlvs* operator ->() { return &self; }
5920 const LDKReceiveTlvs* operator &() const { return &self; }
5921 const LDKReceiveTlvs* operator ->() const { return &self; }
5923 class PaymentRelay {
5925 LDKPaymentRelay self;
5927 PaymentRelay(const PaymentRelay&) = delete;
5928 PaymentRelay(PaymentRelay&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentRelay)); }
5929 PaymentRelay(LDKPaymentRelay&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentRelay)); }
5930 operator LDKPaymentRelay() && { LDKPaymentRelay res = self; memset(&self, 0, sizeof(LDKPaymentRelay)); return res; }
5931 ~PaymentRelay() { PaymentRelay_free(self); }
5932 PaymentRelay& operator=(PaymentRelay&& o) { PaymentRelay_free(self); self = o.self; memset(&o, 0, sizeof(PaymentRelay)); return *this; }
5933 LDKPaymentRelay* operator &() { return &self; }
5934 LDKPaymentRelay* operator ->() { return &self; }
5935 const LDKPaymentRelay* operator &() const { return &self; }
5936 const LDKPaymentRelay* operator ->() const { return &self; }
5938 class PaymentConstraints {
5940 LDKPaymentConstraints self;
5942 PaymentConstraints(const PaymentConstraints&) = delete;
5943 PaymentConstraints(PaymentConstraints&& o) : self(o.self) { memset(&o, 0, sizeof(PaymentConstraints)); }
5944 PaymentConstraints(LDKPaymentConstraints&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPaymentConstraints)); }
5945 operator LDKPaymentConstraints() && { LDKPaymentConstraints res = self; memset(&self, 0, sizeof(LDKPaymentConstraints)); return res; }
5946 ~PaymentConstraints() { PaymentConstraints_free(self); }
5947 PaymentConstraints& operator=(PaymentConstraints&& o) { PaymentConstraints_free(self); self = o.self; memset(&o, 0, sizeof(PaymentConstraints)); return *this; }
5948 LDKPaymentConstraints* operator &() { return &self; }
5949 LDKPaymentConstraints* operator ->() { return &self; }
5950 const LDKPaymentConstraints* operator &() const { return &self; }
5951 const LDKPaymentConstraints* operator ->() const { return &self; }
5953 class UtxoLookupError {
5955 LDKUtxoLookupError self;
5957 UtxoLookupError(const UtxoLookupError&) = delete;
5958 UtxoLookupError(UtxoLookupError&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookupError)); }
5959 UtxoLookupError(LDKUtxoLookupError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookupError)); }
5960 operator LDKUtxoLookupError() && { LDKUtxoLookupError res = self; memset(&self, 0, sizeof(LDKUtxoLookupError)); return res; }
5961 UtxoLookupError& operator=(UtxoLookupError&& o) { self = o.self; memset(&o, 0, sizeof(UtxoLookupError)); return *this; }
5962 LDKUtxoLookupError* operator &() { return &self; }
5963 LDKUtxoLookupError* operator ->() { return &self; }
5964 const LDKUtxoLookupError* operator &() const { return &self; }
5965 const LDKUtxoLookupError* operator ->() const { return &self; }
5971 UtxoResult(const UtxoResult&) = delete;
5972 UtxoResult(UtxoResult&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoResult)); }
5973 UtxoResult(LDKUtxoResult&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoResult)); }
5974 operator LDKUtxoResult() && { LDKUtxoResult res = self; memset(&self, 0, sizeof(LDKUtxoResult)); return res; }
5975 ~UtxoResult() { UtxoResult_free(self); }
5976 UtxoResult& operator=(UtxoResult&& o) { UtxoResult_free(self); self = o.self; memset(&o, 0, sizeof(UtxoResult)); return *this; }
5977 LDKUtxoResult* operator &() { return &self; }
5978 LDKUtxoResult* operator ->() { return &self; }
5979 const LDKUtxoResult* operator &() const { return &self; }
5980 const LDKUtxoResult* operator ->() const { return &self; }
5986 UtxoLookup(const UtxoLookup&) = delete;
5987 UtxoLookup(UtxoLookup&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoLookup)); }
5988 UtxoLookup(LDKUtxoLookup&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoLookup)); }
5989 operator LDKUtxoLookup() && { LDKUtxoLookup res = self; memset(&self, 0, sizeof(LDKUtxoLookup)); return res; }
5990 ~UtxoLookup() { UtxoLookup_free(self); }
5991 UtxoLookup& operator=(UtxoLookup&& o) { UtxoLookup_free(self); self = o.self; memset(&o, 0, sizeof(UtxoLookup)); return *this; }
5992 LDKUtxoLookup* operator &() { return &self; }
5993 LDKUtxoLookup* operator ->() { return &self; }
5994 const LDKUtxoLookup* operator &() const { return &self; }
5995 const LDKUtxoLookup* operator ->() const { return &self; }
5997 * Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
5998 * Returns an error if `chain_hash` is for a different chain or if such a transaction output is
6001 * [`short_channel_id`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#definition-of-short_channel_id
6003 inline LDK::UtxoResult get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id);
6009 UtxoFuture(const UtxoFuture&) = delete;
6010 UtxoFuture(UtxoFuture&& o) : self(o.self) { memset(&o, 0, sizeof(UtxoFuture)); }
6011 UtxoFuture(LDKUtxoFuture&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKUtxoFuture)); }
6012 operator LDKUtxoFuture() && { LDKUtxoFuture res = self; memset(&self, 0, sizeof(LDKUtxoFuture)); return res; }
6013 ~UtxoFuture() { UtxoFuture_free(self); }
6014 UtxoFuture& operator=(UtxoFuture&& o) { UtxoFuture_free(self); self = o.self; memset(&o, 0, sizeof(UtxoFuture)); return *this; }
6015 LDKUtxoFuture* operator &() { return &self; }
6016 LDKUtxoFuture* operator ->() { return &self; }
6017 const LDKUtxoFuture* operator &() const { return &self; }
6018 const LDKUtxoFuture* operator ->() const { return &self; }
6020 class OnionMessenger {
6022 LDKOnionMessenger self;
6024 OnionMessenger(const OnionMessenger&) = delete;
6025 OnionMessenger(OnionMessenger&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessenger)); }
6026 OnionMessenger(LDKOnionMessenger&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessenger)); }
6027 operator LDKOnionMessenger() && { LDKOnionMessenger res = self; memset(&self, 0, sizeof(LDKOnionMessenger)); return res; }
6028 ~OnionMessenger() { OnionMessenger_free(self); }
6029 OnionMessenger& operator=(OnionMessenger&& o) { OnionMessenger_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessenger)); return *this; }
6030 LDKOnionMessenger* operator &() { return &self; }
6031 LDKOnionMessenger* operator ->() { return &self; }
6032 const LDKOnionMessenger* operator &() const { return &self; }
6033 const LDKOnionMessenger* operator ->() const { return &self; }
6035 class MessageRouter {
6037 LDKMessageRouter self;
6039 MessageRouter(const MessageRouter&) = delete;
6040 MessageRouter(MessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(MessageRouter)); }
6041 MessageRouter(LDKMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMessageRouter)); }
6042 operator LDKMessageRouter() && { LDKMessageRouter res = self; memset(&self, 0, sizeof(LDKMessageRouter)); return res; }
6043 ~MessageRouter() { MessageRouter_free(self); }
6044 MessageRouter& operator=(MessageRouter&& o) { MessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(MessageRouter)); return *this; }
6045 LDKMessageRouter* operator &() { return &self; }
6046 LDKMessageRouter* operator ->() { return &self; }
6047 const LDKMessageRouter* operator &() const { return &self; }
6048 const LDKMessageRouter* operator ->() const { return &self; }
6050 * Returns a route for sending an [`OnionMessage`] to the given [`Destination`].
6052 inline LDK::CResult_OnionMessagePathNoneZ find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination);
6054 * Creates [`BlindedPath`]s to the `recipient` node. The nodes in `peers` are assumed to be
6055 * direct peers with the `recipient`.
6057 inline LDK::CResult_CVec_BlindedPathZNoneZ create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers);
6059 class DefaultMessageRouter {
6061 LDKDefaultMessageRouter self;
6063 DefaultMessageRouter(const DefaultMessageRouter&) = delete;
6064 DefaultMessageRouter(DefaultMessageRouter&& o) : self(o.self) { memset(&o, 0, sizeof(DefaultMessageRouter)); }
6065 DefaultMessageRouter(LDKDefaultMessageRouter&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDefaultMessageRouter)); }
6066 operator LDKDefaultMessageRouter() && { LDKDefaultMessageRouter res = self; memset(&self, 0, sizeof(LDKDefaultMessageRouter)); return res; }
6067 ~DefaultMessageRouter() { DefaultMessageRouter_free(self); }
6068 DefaultMessageRouter& operator=(DefaultMessageRouter&& o) { DefaultMessageRouter_free(self); self = o.self; memset(&o, 0, sizeof(DefaultMessageRouter)); return *this; }
6069 LDKDefaultMessageRouter* operator &() { return &self; }
6070 LDKDefaultMessageRouter* operator ->() { return &self; }
6071 const LDKDefaultMessageRouter* operator &() const { return &self; }
6072 const LDKDefaultMessageRouter* operator ->() const { return &self; }
6074 class OnionMessagePath {
6076 LDKOnionMessagePath self;
6078 OnionMessagePath(const OnionMessagePath&) = delete;
6079 OnionMessagePath(OnionMessagePath&& o) : self(o.self) { memset(&o, 0, sizeof(OnionMessagePath)); }
6080 OnionMessagePath(LDKOnionMessagePath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKOnionMessagePath)); }
6081 operator LDKOnionMessagePath() && { LDKOnionMessagePath res = self; memset(&self, 0, sizeof(LDKOnionMessagePath)); return res; }
6082 ~OnionMessagePath() { OnionMessagePath_free(self); }
6083 OnionMessagePath& operator=(OnionMessagePath&& o) { OnionMessagePath_free(self); self = o.self; memset(&o, 0, sizeof(OnionMessagePath)); return *this; }
6084 LDKOnionMessagePath* operator &() { return &self; }
6085 LDKOnionMessagePath* operator ->() { return &self; }
6086 const LDKOnionMessagePath* operator &() const { return &self; }
6087 const LDKOnionMessagePath* operator ->() const { return &self; }
6091 LDKDestination self;
6093 Destination(const Destination&) = delete;
6094 Destination(Destination&& o) : self(o.self) { memset(&o, 0, sizeof(Destination)); }
6095 Destination(LDKDestination&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDestination)); }
6096 operator LDKDestination() && { LDKDestination res = self; memset(&self, 0, sizeof(LDKDestination)); return res; }
6097 ~Destination() { Destination_free(self); }
6098 Destination& operator=(Destination&& o) { Destination_free(self); self = o.self; memset(&o, 0, sizeof(Destination)); return *this; }
6099 LDKDestination* operator &() { return &self; }
6100 LDKDestination* operator ->() { return &self; }
6101 const LDKDestination* operator &() const { return &self; }
6102 const LDKDestination* operator ->() const { return &self; }
6106 LDKSendSuccess self;
6108 SendSuccess(const SendSuccess&) = delete;
6109 SendSuccess(SendSuccess&& o) : self(o.self) { memset(&o, 0, sizeof(SendSuccess)); }
6110 SendSuccess(LDKSendSuccess&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendSuccess)); }
6111 operator LDKSendSuccess() && { LDKSendSuccess res = self; memset(&self, 0, sizeof(LDKSendSuccess)); return res; }
6112 ~SendSuccess() { SendSuccess_free(self); }
6113 SendSuccess& operator=(SendSuccess&& o) { SendSuccess_free(self); self = o.self; memset(&o, 0, sizeof(SendSuccess)); return *this; }
6114 LDKSendSuccess* operator &() { return &self; }
6115 LDKSendSuccess* operator ->() { return &self; }
6116 const LDKSendSuccess* operator &() const { return &self; }
6117 const LDKSendSuccess* operator ->() const { return &self; }
6123 SendError(const SendError&) = delete;
6124 SendError(SendError&& o) : self(o.self) { memset(&o, 0, sizeof(SendError)); }
6125 SendError(LDKSendError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKSendError)); }
6126 operator LDKSendError() && { LDKSendError res = self; memset(&self, 0, sizeof(LDKSendError)); return res; }
6127 ~SendError() { SendError_free(self); }
6128 SendError& operator=(SendError&& o) { SendError_free(self); self = o.self; memset(&o, 0, sizeof(SendError)); return *this; }
6129 LDKSendError* operator &() { return &self; }
6130 LDKSendError* operator ->() { return &self; }
6131 const LDKSendError* operator &() const { return &self; }
6132 const LDKSendError* operator ->() const { return &self; }
6134 class CustomOnionMessageHandler {
6136 LDKCustomOnionMessageHandler self;
6138 CustomOnionMessageHandler(const CustomOnionMessageHandler&) = delete;
6139 CustomOnionMessageHandler(CustomOnionMessageHandler&& o) : self(o.self) { memset(&o, 0, sizeof(CustomOnionMessageHandler)); }
6140 CustomOnionMessageHandler(LDKCustomOnionMessageHandler&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCustomOnionMessageHandler)); }
6141 operator LDKCustomOnionMessageHandler() && { LDKCustomOnionMessageHandler res = self; memset(&self, 0, sizeof(LDKCustomOnionMessageHandler)); return res; }
6142 ~CustomOnionMessageHandler() { CustomOnionMessageHandler_free(self); }
6143 CustomOnionMessageHandler& operator=(CustomOnionMessageHandler&& o) { CustomOnionMessageHandler_free(self); self = o.self; memset(&o, 0, sizeof(CustomOnionMessageHandler)); return *this; }
6144 LDKCustomOnionMessageHandler* operator &() { return &self; }
6145 LDKCustomOnionMessageHandler* operator ->() { return &self; }
6146 const LDKCustomOnionMessageHandler* operator &() const { return &self; }
6147 const LDKCustomOnionMessageHandler* operator ->() const { return &self; }
6149 * Called with the custom message that was received, returning a response to send, if any.
6151 * The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
6153 inline LDK::COption_OnionMessageContentsZ handle_custom_message(struct LDKOnionMessageContents msg);
6155 * Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
6156 * message type is unknown.
6158 inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ read_custom_message(uint64_t message_type, struct LDKu8slice buffer);
6160 * Releases any [`Self::CustomMessage`]s that need to be sent.
6162 * Typically, this is used for messages initiating a message flow rather than in response to
6163 * another message. The latter should use the return value of [`Self::handle_custom_message`].
6165 inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ release_pending_custom_messages();
6169 LDKPeeledOnion self;
6171 PeeledOnion(const PeeledOnion&) = delete;
6172 PeeledOnion(PeeledOnion&& o) : self(o.self) { memset(&o, 0, sizeof(PeeledOnion)); }
6173 PeeledOnion(LDKPeeledOnion&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPeeledOnion)); }
6174 operator LDKPeeledOnion() && { LDKPeeledOnion res = self; memset(&self, 0, sizeof(LDKPeeledOnion)); return res; }
6175 ~PeeledOnion() { PeeledOnion_free(self); }
6176 PeeledOnion& operator=(PeeledOnion&& o) { PeeledOnion_free(self); self = o.self; memset(&o, 0, sizeof(PeeledOnion)); return *this; }
6177 LDKPeeledOnion* operator &() { return &self; }
6178 LDKPeeledOnion* operator ->() { return &self; }
6179 const LDKPeeledOnion* operator &() const { return &self; }
6180 const LDKPeeledOnion* operator ->() const { return &self; }
6182 class FilesystemStore {
6184 LDKFilesystemStore self;
6186 FilesystemStore(const FilesystemStore&) = delete;
6187 FilesystemStore(FilesystemStore&& o) : self(o.self) { memset(&o, 0, sizeof(FilesystemStore)); }
6188 FilesystemStore(LDKFilesystemStore&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKFilesystemStore)); }
6189 operator LDKFilesystemStore() && { LDKFilesystemStore res = self; memset(&self, 0, sizeof(LDKFilesystemStore)); return res; }
6190 ~FilesystemStore() { FilesystemStore_free(self); }
6191 FilesystemStore& operator=(FilesystemStore&& o) { FilesystemStore_free(self); self = o.self; memset(&o, 0, sizeof(FilesystemStore)); return *this; }
6192 LDKFilesystemStore* operator &() { return &self; }
6193 LDKFilesystemStore* operator ->() { return &self; }
6194 const LDKFilesystemStore* operator &() const { return &self; }
6195 const LDKFilesystemStore* operator ->() const { return &self; }
6199 LDKBlindedPath self;
6201 BlindedPath(const BlindedPath&) = delete;
6202 BlindedPath(BlindedPath&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedPath)); }
6203 BlindedPath(LDKBlindedPath&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedPath)); }
6204 operator LDKBlindedPath() && { LDKBlindedPath res = self; memset(&self, 0, sizeof(LDKBlindedPath)); return res; }
6205 ~BlindedPath() { BlindedPath_free(self); }
6206 BlindedPath& operator=(BlindedPath&& o) { BlindedPath_free(self); self = o.self; memset(&o, 0, sizeof(BlindedPath)); return *this; }
6207 LDKBlindedPath* operator &() { return &self; }
6208 LDKBlindedPath* operator ->() { return &self; }
6209 const LDKBlindedPath* operator &() const { return &self; }
6210 const LDKBlindedPath* operator ->() const { return &self; }
6216 BlindedHop(const BlindedHop&) = delete;
6217 BlindedHop(BlindedHop&& o) : self(o.self) { memset(&o, 0, sizeof(BlindedHop)); }
6218 BlindedHop(LDKBlindedHop&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKBlindedHop)); }
6219 operator LDKBlindedHop() && { LDKBlindedHop res = self; memset(&self, 0, sizeof(LDKBlindedHop)); return res; }
6220 ~BlindedHop() { BlindedHop_free(self); }
6221 BlindedHop& operator=(BlindedHop&& o) { BlindedHop_free(self); self = o.self; memset(&o, 0, sizeof(BlindedHop)); return *this; }
6222 LDKBlindedHop* operator &() { return &self; }
6223 LDKBlindedHop* operator ->() { return &self; }
6224 const LDKBlindedHop* operator &() const { return &self; }
6225 const LDKBlindedHop* operator ->() const { return &self; }
6227 class InvoiceError {
6229 LDKInvoiceError self;
6231 InvoiceError(const InvoiceError&) = delete;
6232 InvoiceError(InvoiceError&& o) : self(o.self) { memset(&o, 0, sizeof(InvoiceError)); }
6233 InvoiceError(LDKInvoiceError&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKInvoiceError)); }
6234 operator LDKInvoiceError() && { LDKInvoiceError res = self; memset(&self, 0, sizeof(LDKInvoiceError)); return res; }
6235 ~InvoiceError() { InvoiceError_free(self); }
6236 InvoiceError& operator=(InvoiceError&& o) { InvoiceError_free(self); self = o.self; memset(&o, 0, sizeof(InvoiceError)); return *this; }
6237 LDKInvoiceError* operator &() { return &self; }
6238 LDKInvoiceError* operator ->() { return &self; }
6239 const LDKInvoiceError* operator &() const { return &self; }
6240 const LDKInvoiceError* operator ->() const { return &self; }
6242 class ErroneousField {
6244 LDKErroneousField self;
6246 ErroneousField(const ErroneousField&) = delete;
6247 ErroneousField(ErroneousField&& o) : self(o.self) { memset(&o, 0, sizeof(ErroneousField)); }
6248 ErroneousField(LDKErroneousField&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKErroneousField)); }
6249 operator LDKErroneousField() && { LDKErroneousField res = self; memset(&self, 0, sizeof(LDKErroneousField)); return res; }
6250 ~ErroneousField() { ErroneousField_free(self); }
6251 ErroneousField& operator=(ErroneousField&& o) { ErroneousField_free(self); self = o.self; memset(&o, 0, sizeof(ErroneousField)); return *this; }
6252 LDKErroneousField* operator &() { return &self; }
6253 LDKErroneousField* operator ->() { return &self; }
6254 const LDKErroneousField* operator &() const { return &self; }
6255 const LDKErroneousField* operator ->() const { return &self; }
6257 class DelayedPaymentBasepoint {
6259 LDKDelayedPaymentBasepoint self;
6261 DelayedPaymentBasepoint(const DelayedPaymentBasepoint&) = delete;
6262 DelayedPaymentBasepoint(DelayedPaymentBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentBasepoint)); }
6263 DelayedPaymentBasepoint(LDKDelayedPaymentBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentBasepoint)); }
6264 operator LDKDelayedPaymentBasepoint() && { LDKDelayedPaymentBasepoint res = self; memset(&self, 0, sizeof(LDKDelayedPaymentBasepoint)); return res; }
6265 ~DelayedPaymentBasepoint() { DelayedPaymentBasepoint_free(self); }
6266 DelayedPaymentBasepoint& operator=(DelayedPaymentBasepoint&& o) { DelayedPaymentBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentBasepoint)); return *this; }
6267 LDKDelayedPaymentBasepoint* operator &() { return &self; }
6268 LDKDelayedPaymentBasepoint* operator ->() { return &self; }
6269 const LDKDelayedPaymentBasepoint* operator &() const { return &self; }
6270 const LDKDelayedPaymentBasepoint* operator ->() const { return &self; }
6272 class DelayedPaymentKey {
6274 LDKDelayedPaymentKey self;
6276 DelayedPaymentKey(const DelayedPaymentKey&) = delete;
6277 DelayedPaymentKey(DelayedPaymentKey&& o) : self(o.self) { memset(&o, 0, sizeof(DelayedPaymentKey)); }
6278 DelayedPaymentKey(LDKDelayedPaymentKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKDelayedPaymentKey)); }
6279 operator LDKDelayedPaymentKey() && { LDKDelayedPaymentKey res = self; memset(&self, 0, sizeof(LDKDelayedPaymentKey)); return res; }
6280 ~DelayedPaymentKey() { DelayedPaymentKey_free(self); }
6281 DelayedPaymentKey& operator=(DelayedPaymentKey&& o) { DelayedPaymentKey_free(self); self = o.self; memset(&o, 0, sizeof(DelayedPaymentKey)); return *this; }
6282 LDKDelayedPaymentKey* operator &() { return &self; }
6283 LDKDelayedPaymentKey* operator ->() { return &self; }
6284 const LDKDelayedPaymentKey* operator &() const { return &self; }
6285 const LDKDelayedPaymentKey* operator ->() const { return &self; }
6287 class HtlcBasepoint {
6289 LDKHtlcBasepoint self;
6291 HtlcBasepoint(const HtlcBasepoint&) = delete;
6292 HtlcBasepoint(HtlcBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcBasepoint)); }
6293 HtlcBasepoint(LDKHtlcBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcBasepoint)); }
6294 operator LDKHtlcBasepoint() && { LDKHtlcBasepoint res = self; memset(&self, 0, sizeof(LDKHtlcBasepoint)); return res; }
6295 ~HtlcBasepoint() { HtlcBasepoint_free(self); }
6296 HtlcBasepoint& operator=(HtlcBasepoint&& o) { HtlcBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(HtlcBasepoint)); return *this; }
6297 LDKHtlcBasepoint* operator &() { return &self; }
6298 LDKHtlcBasepoint* operator ->() { return &self; }
6299 const LDKHtlcBasepoint* operator &() const { return &self; }
6300 const LDKHtlcBasepoint* operator ->() const { return &self; }
6306 HtlcKey(const HtlcKey&) = delete;
6307 HtlcKey(HtlcKey&& o) : self(o.self) { memset(&o, 0, sizeof(HtlcKey)); }
6308 HtlcKey(LDKHtlcKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKHtlcKey)); }
6309 operator LDKHtlcKey() && { LDKHtlcKey res = self; memset(&self, 0, sizeof(LDKHtlcKey)); return res; }
6310 ~HtlcKey() { HtlcKey_free(self); }
6311 HtlcKey& operator=(HtlcKey&& o) { HtlcKey_free(self); self = o.self; memset(&o, 0, sizeof(HtlcKey)); return *this; }
6312 LDKHtlcKey* operator &() { return &self; }
6313 LDKHtlcKey* operator ->() { return &self; }
6314 const LDKHtlcKey* operator &() const { return &self; }
6315 const LDKHtlcKey* operator ->() const { return &self; }
6317 class RevocationBasepoint {
6319 LDKRevocationBasepoint self;
6321 RevocationBasepoint(const RevocationBasepoint&) = delete;
6322 RevocationBasepoint(RevocationBasepoint&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationBasepoint)); }
6323 RevocationBasepoint(LDKRevocationBasepoint&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationBasepoint)); }
6324 operator LDKRevocationBasepoint() && { LDKRevocationBasepoint res = self; memset(&self, 0, sizeof(LDKRevocationBasepoint)); return res; }
6325 ~RevocationBasepoint() { RevocationBasepoint_free(self); }
6326 RevocationBasepoint& operator=(RevocationBasepoint&& o) { RevocationBasepoint_free(self); self = o.self; memset(&o, 0, sizeof(RevocationBasepoint)); return *this; }
6327 LDKRevocationBasepoint* operator &() { return &self; }
6328 LDKRevocationBasepoint* operator ->() { return &self; }
6329 const LDKRevocationBasepoint* operator &() const { return &self; }
6330 const LDKRevocationBasepoint* operator ->() const { return &self; }
6332 class RevocationKey {
6334 LDKRevocationKey self;
6336 RevocationKey(const RevocationKey&) = delete;
6337 RevocationKey(RevocationKey&& o) : self(o.self) { memset(&o, 0, sizeof(RevocationKey)); }
6338 RevocationKey(LDKRevocationKey&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKRevocationKey)); }
6339 operator LDKRevocationKey() && { LDKRevocationKey res = self; memset(&self, 0, sizeof(LDKRevocationKey)); return res; }
6340 ~RevocationKey() { RevocationKey_free(self); }
6341 RevocationKey& operator=(RevocationKey&& o) { RevocationKey_free(self); self = o.self; memset(&o, 0, sizeof(RevocationKey)); return *this; }
6342 LDKRevocationKey* operator &() { return &self; }
6343 LDKRevocationKey* operator ->() { return &self; }
6344 const LDKRevocationKey* operator &() const { return &self; }
6345 const LDKRevocationKey* operator ->() const { return &self; }
6347 class MonitorUpdateId {
6349 LDKMonitorUpdateId self;
6351 MonitorUpdateId(const MonitorUpdateId&) = delete;
6352 MonitorUpdateId(MonitorUpdateId&& o) : self(o.self) { memset(&o, 0, sizeof(MonitorUpdateId)); }
6353 MonitorUpdateId(LDKMonitorUpdateId&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKMonitorUpdateId)); }
6354 operator LDKMonitorUpdateId() && { LDKMonitorUpdateId res = self; memset(&self, 0, sizeof(LDKMonitorUpdateId)); return res; }
6355 ~MonitorUpdateId() { MonitorUpdateId_free(self); }
6356 MonitorUpdateId& operator=(MonitorUpdateId&& o) { MonitorUpdateId_free(self); self = o.self; memset(&o, 0, sizeof(MonitorUpdateId)); return *this; }
6357 LDKMonitorUpdateId* operator &() { return &self; }
6358 LDKMonitorUpdateId* operator ->() { return &self; }
6359 const LDKMonitorUpdateId* operator &() const { return &self; }
6360 const LDKMonitorUpdateId* operator ->() const { return &self; }
6366 Persist(const Persist&) = delete;
6367 Persist(Persist&& o) : self(o.self) { memset(&o, 0, sizeof(Persist)); }
6368 Persist(LDKPersist&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKPersist)); }
6369 operator LDKPersist() && { LDKPersist res = self; memset(&self, 0, sizeof(LDKPersist)); return res; }
6370 ~Persist() { Persist_free(self); }
6371 Persist& operator=(Persist&& o) { Persist_free(self); self = o.self; memset(&o, 0, sizeof(Persist)); return *this; }
6372 LDKPersist* operator &() { return &self; }
6373 LDKPersist* operator ->() { return &self; }
6374 const LDKPersist* operator &() const { return &self; }
6375 const LDKPersist* operator ->() const { return &self; }
6377 * Persist a new channel's data in response to a [`chain::Watch::watch_channel`] call. This is
6378 * called by [`ChannelManager`] for new channels, or may be called directly, e.g. on startup.
6380 * The data can be stored any way you want, but the identifier provided by LDK is the
6381 * channel's outpoint (and it is up to you to maintain a correct mapping between the outpoint
6382 * and the stored channel data). Note that you **must** persist every new monitor to disk.
6384 * The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
6385 * if you return [`ChannelMonitorUpdateStatus::InProgress`].
6387 * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`
6388 * and [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
6390 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
6391 * [`Writeable::write`]: crate::util::ser::Writeable::write
6393 inline LDK::ChannelMonitorUpdateStatus persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
6395 * Update one channel's data. The provided [`ChannelMonitor`] has already applied the given
6398 * Note that on every update, you **must** persist either the [`ChannelMonitorUpdate`] or the
6399 * updated monitor itself to disk/backups. See the [`Persist`] trait documentation for more
6402 * During blockchain synchronization operations, and in some rare cases, this may be called with
6403 * no [`ChannelMonitorUpdate`], in which case the full [`ChannelMonitor`] needs to be persisted.
6404 * Note that after the full [`ChannelMonitor`] is persisted any previous
6405 * [`ChannelMonitorUpdate`]s which were persisted should be discarded - they can no longer be
6406 * applied to the persisted [`ChannelMonitor`] as they were already applied.
6408 * If an implementer chooses to persist the updates only, they need to make
6409 * sure that all the updates are applied to the `ChannelMonitors` *before*
6410 * the set of channel monitors is given to the `ChannelManager`
6411 * deserialization routine. See [`ChannelMonitor::update_monitor`] for
6412 * applying a monitor update to a monitor. If full `ChannelMonitors` are
6413 * persisted, then there is no need to persist individual updates.
6415 * Note that there could be a performance tradeoff between persisting complete
6416 * channel monitors on every update vs. persisting only updates and applying
6417 * them in batches. The size of each monitor grows `O(number of state updates)`
6418 * whereas updates are small and `O(1)`.
6420 * The `update_id` is used to identify this call to [`ChainMonitor::channel_monitor_updated`],
6421 * if you return [`ChannelMonitorUpdateStatus::InProgress`].
6423 * See [`Writeable::write`] on [`ChannelMonitor`] for writing out a `ChannelMonitor`,
6424 * [`Writeable::write`] on [`ChannelMonitorUpdate`] for writing out an update, and
6425 * [`ChannelMonitorUpdateStatus`] for requirements when returning errors.
6427 * [`Writeable::write`]: crate::util::ser::Writeable::write
6429 * Note that update (or a relevant inner pointer) may be NULL or all-0s to represent None
6431 inline LDK::ChannelMonitorUpdateStatus update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id);
6433 class LockedChannelMonitor {
6435 LDKLockedChannelMonitor self;
6437 LockedChannelMonitor(const LockedChannelMonitor&) = delete;
6438 LockedChannelMonitor(LockedChannelMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(LockedChannelMonitor)); }
6439 LockedChannelMonitor(LDKLockedChannelMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKLockedChannelMonitor)); }
6440 operator LDKLockedChannelMonitor() && { LDKLockedChannelMonitor res = self; memset(&self, 0, sizeof(LDKLockedChannelMonitor)); return res; }
6441 ~LockedChannelMonitor() { LockedChannelMonitor_free(self); }
6442 LockedChannelMonitor& operator=(LockedChannelMonitor&& o) { LockedChannelMonitor_free(self); self = o.self; memset(&o, 0, sizeof(LockedChannelMonitor)); return *this; }
6443 LDKLockedChannelMonitor* operator &() { return &self; }
6444 LDKLockedChannelMonitor* operator ->() { return &self; }
6445 const LDKLockedChannelMonitor* operator &() const { return &self; }
6446 const LDKLockedChannelMonitor* operator ->() const { return &self; }
6448 class ChainMonitor {
6450 LDKChainMonitor self;
6452 ChainMonitor(const ChainMonitor&) = delete;
6453 ChainMonitor(ChainMonitor&& o) : self(o.self) { memset(&o, 0, sizeof(ChainMonitor)); }
6454 ChainMonitor(LDKChainMonitor&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKChainMonitor)); }
6455 operator LDKChainMonitor() && { LDKChainMonitor res = self; memset(&self, 0, sizeof(LDKChainMonitor)); return res; }
6456 ~ChainMonitor() { ChainMonitor_free(self); }
6457 ChainMonitor& operator=(ChainMonitor&& o) { ChainMonitor_free(self); self = o.self; memset(&o, 0, sizeof(ChainMonitor)); return *this; }
6458 LDKChainMonitor* operator &() { return &self; }
6459 LDKChainMonitor* operator ->() { return &self; }
6460 const LDKChainMonitor* operator &() const { return &self; }
6461 const LDKChainMonitor* operator ->() const { return &self; }
6463 class CResult_HtlcKeyDecodeErrorZ {
6465 LDKCResult_HtlcKeyDecodeErrorZ self;
6467 CResult_HtlcKeyDecodeErrorZ(const CResult_HtlcKeyDecodeErrorZ&) = delete;
6468 CResult_HtlcKeyDecodeErrorZ(CResult_HtlcKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); }
6469 CResult_HtlcKeyDecodeErrorZ(LDKCResult_HtlcKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); }
6470 operator LDKCResult_HtlcKeyDecodeErrorZ() && { LDKCResult_HtlcKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcKeyDecodeErrorZ)); return res; }
6471 ~CResult_HtlcKeyDecodeErrorZ() { CResult_HtlcKeyDecodeErrorZ_free(self); }
6472 CResult_HtlcKeyDecodeErrorZ& operator=(CResult_HtlcKeyDecodeErrorZ&& o) { CResult_HtlcKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcKeyDecodeErrorZ)); return *this; }
6473 LDKCResult_HtlcKeyDecodeErrorZ* operator &() { return &self; }
6474 LDKCResult_HtlcKeyDecodeErrorZ* operator ->() { return &self; }
6475 const LDKCResult_HtlcKeyDecodeErrorZ* operator &() const { return &self; }
6476 const LDKCResult_HtlcKeyDecodeErrorZ* operator ->() const { return &self; }
6478 class CResult_TransactionU16LenLimitedNoneZ {
6480 LDKCResult_TransactionU16LenLimitedNoneZ self;
6482 CResult_TransactionU16LenLimitedNoneZ(const CResult_TransactionU16LenLimitedNoneZ&) = delete;
6483 CResult_TransactionU16LenLimitedNoneZ(CResult_TransactionU16LenLimitedNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); }
6484 CResult_TransactionU16LenLimitedNoneZ(LDKCResult_TransactionU16LenLimitedNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); }
6485 operator LDKCResult_TransactionU16LenLimitedNoneZ() && { LDKCResult_TransactionU16LenLimitedNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedNoneZ)); return res; }
6486 ~CResult_TransactionU16LenLimitedNoneZ() { CResult_TransactionU16LenLimitedNoneZ_free(self); }
6487 CResult_TransactionU16LenLimitedNoneZ& operator=(CResult_TransactionU16LenLimitedNoneZ&& o) { CResult_TransactionU16LenLimitedNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedNoneZ)); return *this; }
6488 LDKCResult_TransactionU16LenLimitedNoneZ* operator &() { return &self; }
6489 LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() { return &self; }
6490 const LDKCResult_TransactionU16LenLimitedNoneZ* operator &() const { return &self; }
6491 const LDKCResult_TransactionU16LenLimitedNoneZ* operator ->() const { return &self; }
6493 class CResult_LockedChannelMonitorNoneZ {
6495 LDKCResult_LockedChannelMonitorNoneZ self;
6497 CResult_LockedChannelMonitorNoneZ(const CResult_LockedChannelMonitorNoneZ&) = delete;
6498 CResult_LockedChannelMonitorNoneZ(CResult_LockedChannelMonitorNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); }
6499 CResult_LockedChannelMonitorNoneZ(LDKCResult_LockedChannelMonitorNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); }
6500 operator LDKCResult_LockedChannelMonitorNoneZ() && { LDKCResult_LockedChannelMonitorNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_LockedChannelMonitorNoneZ)); return res; }
6501 ~CResult_LockedChannelMonitorNoneZ() { CResult_LockedChannelMonitorNoneZ_free(self); }
6502 CResult_LockedChannelMonitorNoneZ& operator=(CResult_LockedChannelMonitorNoneZ&& o) { CResult_LockedChannelMonitorNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_LockedChannelMonitorNoneZ)); return *this; }
6503 LDKCResult_LockedChannelMonitorNoneZ* operator &() { return &self; }
6504 LDKCResult_LockedChannelMonitorNoneZ* operator ->() { return &self; }
6505 const LDKCResult_LockedChannelMonitorNoneZ* operator &() const { return &self; }
6506 const LDKCResult_LockedChannelMonitorNoneZ* operator ->() const { return &self; }
6508 class CVec_C2Tuple_BlindedPayInfoBlindedPathZZ {
6510 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ self;
6512 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(const CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&) = delete;
6513 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6514 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); }
6515 operator LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ() && { LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ)); return res; }
6516 ~CVec_C2Tuple_BlindedPayInfoBlindedPathZZ() { CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(self); }
6517 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; }
6518 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() { return &self; }
6519 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() { return &self; }
6520 const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator &() const { return &self; }
6521 const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ* operator ->() const { return &self; }
6523 class CResult_PhantomRouteHintsDecodeErrorZ {
6525 LDKCResult_PhantomRouteHintsDecodeErrorZ self;
6527 CResult_PhantomRouteHintsDecodeErrorZ(const CResult_PhantomRouteHintsDecodeErrorZ&) = delete;
6528 CResult_PhantomRouteHintsDecodeErrorZ(CResult_PhantomRouteHintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); }
6529 CResult_PhantomRouteHintsDecodeErrorZ(LDKCResult_PhantomRouteHintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); }
6530 operator LDKCResult_PhantomRouteHintsDecodeErrorZ() && { LDKCResult_PhantomRouteHintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ)); return res; }
6531 ~CResult_PhantomRouteHintsDecodeErrorZ() { CResult_PhantomRouteHintsDecodeErrorZ_free(self); }
6532 CResult_PhantomRouteHintsDecodeErrorZ& operator=(CResult_PhantomRouteHintsDecodeErrorZ&& o) { CResult_PhantomRouteHintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PhantomRouteHintsDecodeErrorZ)); return *this; }
6533 LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() { return &self; }
6534 LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() { return &self; }
6535 const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator &() const { return &self; }
6536 const LDKCResult_PhantomRouteHintsDecodeErrorZ* operator ->() const { return &self; }
6538 class CResult_FundingCreatedDecodeErrorZ {
6540 LDKCResult_FundingCreatedDecodeErrorZ self;
6542 CResult_FundingCreatedDecodeErrorZ(const CResult_FundingCreatedDecodeErrorZ&) = delete;
6543 CResult_FundingCreatedDecodeErrorZ(CResult_FundingCreatedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); }
6544 CResult_FundingCreatedDecodeErrorZ(LDKCResult_FundingCreatedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); }
6545 operator LDKCResult_FundingCreatedDecodeErrorZ() && { LDKCResult_FundingCreatedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingCreatedDecodeErrorZ)); return res; }
6546 ~CResult_FundingCreatedDecodeErrorZ() { CResult_FundingCreatedDecodeErrorZ_free(self); }
6547 CResult_FundingCreatedDecodeErrorZ& operator=(CResult_FundingCreatedDecodeErrorZ&& o) { CResult_FundingCreatedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingCreatedDecodeErrorZ)); return *this; }
6548 LDKCResult_FundingCreatedDecodeErrorZ* operator &() { return &self; }
6549 LDKCResult_FundingCreatedDecodeErrorZ* operator ->() { return &self; }
6550 const LDKCResult_FundingCreatedDecodeErrorZ* operator &() const { return &self; }
6551 const LDKCResult_FundingCreatedDecodeErrorZ* operator ->() const { return &self; }
6553 class CVec_C2Tuple_u32TxOutZZ {
6555 LDKCVec_C2Tuple_u32TxOutZZ self;
6557 CVec_C2Tuple_u32TxOutZZ(const CVec_C2Tuple_u32TxOutZZ&) = delete;
6558 CVec_C2Tuple_u32TxOutZZ(CVec_C2Tuple_u32TxOutZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32TxOutZZ)); }
6559 CVec_C2Tuple_u32TxOutZZ(LDKCVec_C2Tuple_u32TxOutZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); }
6560 operator LDKCVec_C2Tuple_u32TxOutZZ() && { LDKCVec_C2Tuple_u32TxOutZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32TxOutZZ)); return res; }
6561 ~CVec_C2Tuple_u32TxOutZZ() { CVec_C2Tuple_u32TxOutZZ_free(self); }
6562 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; }
6563 LDKCVec_C2Tuple_u32TxOutZZ* operator &() { return &self; }
6564 LDKCVec_C2Tuple_u32TxOutZZ* operator ->() { return &self; }
6565 const LDKCVec_C2Tuple_u32TxOutZZ* operator &() const { return &self; }
6566 const LDKCVec_C2Tuple_u32TxOutZZ* operator ->() const { return &self; }
6568 class CResult_RetryDecodeErrorZ {
6570 LDKCResult_RetryDecodeErrorZ self;
6572 CResult_RetryDecodeErrorZ(const CResult_RetryDecodeErrorZ&) = delete;
6573 CResult_RetryDecodeErrorZ(CResult_RetryDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); }
6574 CResult_RetryDecodeErrorZ(LDKCResult_RetryDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); }
6575 operator LDKCResult_RetryDecodeErrorZ() && { LDKCResult_RetryDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RetryDecodeErrorZ)); return res; }
6576 ~CResult_RetryDecodeErrorZ() { CResult_RetryDecodeErrorZ_free(self); }
6577 CResult_RetryDecodeErrorZ& operator=(CResult_RetryDecodeErrorZ&& o) { CResult_RetryDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RetryDecodeErrorZ)); return *this; }
6578 LDKCResult_RetryDecodeErrorZ* operator &() { return &self; }
6579 LDKCResult_RetryDecodeErrorZ* operator ->() { return &self; }
6580 const LDKCResult_RetryDecodeErrorZ* operator &() const { return &self; }
6581 const LDKCResult_RetryDecodeErrorZ* operator ->() const { return &self; }
6583 class CResult_BlindedForwardDecodeErrorZ {
6585 LDKCResult_BlindedForwardDecodeErrorZ self;
6587 CResult_BlindedForwardDecodeErrorZ(const CResult_BlindedForwardDecodeErrorZ&) = delete;
6588 CResult_BlindedForwardDecodeErrorZ(CResult_BlindedForwardDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); }
6589 CResult_BlindedForwardDecodeErrorZ(LDKCResult_BlindedForwardDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); }
6590 operator LDKCResult_BlindedForwardDecodeErrorZ() && { LDKCResult_BlindedForwardDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedForwardDecodeErrorZ)); return res; }
6591 ~CResult_BlindedForwardDecodeErrorZ() { CResult_BlindedForwardDecodeErrorZ_free(self); }
6592 CResult_BlindedForwardDecodeErrorZ& operator=(CResult_BlindedForwardDecodeErrorZ&& o) { CResult_BlindedForwardDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedForwardDecodeErrorZ)); return *this; }
6593 LDKCResult_BlindedForwardDecodeErrorZ* operator &() { return &self; }
6594 LDKCResult_BlindedForwardDecodeErrorZ* operator ->() { return &self; }
6595 const LDKCResult_BlindedForwardDecodeErrorZ* operator &() const { return &self; }
6596 const LDKCResult_BlindedForwardDecodeErrorZ* operator ->() const { return &self; }
6598 class CResult_ChannelInfoDecodeErrorZ {
6600 LDKCResult_ChannelInfoDecodeErrorZ self;
6602 CResult_ChannelInfoDecodeErrorZ(const CResult_ChannelInfoDecodeErrorZ&) = delete;
6603 CResult_ChannelInfoDecodeErrorZ(CResult_ChannelInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); }
6604 CResult_ChannelInfoDecodeErrorZ(LDKCResult_ChannelInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); }
6605 operator LDKCResult_ChannelInfoDecodeErrorZ() && { LDKCResult_ChannelInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelInfoDecodeErrorZ)); return res; }
6606 ~CResult_ChannelInfoDecodeErrorZ() { CResult_ChannelInfoDecodeErrorZ_free(self); }
6607 CResult_ChannelInfoDecodeErrorZ& operator=(CResult_ChannelInfoDecodeErrorZ&& o) { CResult_ChannelInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelInfoDecodeErrorZ)); return *this; }
6608 LDKCResult_ChannelInfoDecodeErrorZ* operator &() { return &self; }
6609 LDKCResult_ChannelInfoDecodeErrorZ* operator ->() { return &self; }
6610 const LDKCResult_ChannelInfoDecodeErrorZ* operator &() const { return &self; }
6611 const LDKCResult_ChannelInfoDecodeErrorZ* operator ->() const { return &self; }
6613 class COption_MaxDustHTLCExposureZ {
6615 LDKCOption_MaxDustHTLCExposureZ self;
6617 COption_MaxDustHTLCExposureZ(const COption_MaxDustHTLCExposureZ&) = delete;
6618 COption_MaxDustHTLCExposureZ(COption_MaxDustHTLCExposureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); }
6619 COption_MaxDustHTLCExposureZ(LDKCOption_MaxDustHTLCExposureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); }
6620 operator LDKCOption_MaxDustHTLCExposureZ() && { LDKCOption_MaxDustHTLCExposureZ res = self; memset(&self, 0, sizeof(LDKCOption_MaxDustHTLCExposureZ)); return res; }
6621 ~COption_MaxDustHTLCExposureZ() { COption_MaxDustHTLCExposureZ_free(self); }
6622 COption_MaxDustHTLCExposureZ& operator=(COption_MaxDustHTLCExposureZ&& o) { COption_MaxDustHTLCExposureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MaxDustHTLCExposureZ)); return *this; }
6623 LDKCOption_MaxDustHTLCExposureZ* operator &() { return &self; }
6624 LDKCOption_MaxDustHTLCExposureZ* operator ->() { return &self; }
6625 const LDKCOption_MaxDustHTLCExposureZ* operator &() const { return &self; }
6626 const LDKCOption_MaxDustHTLCExposureZ* operator ->() const { return &self; }
6628 class COption_OffersMessageZ {
6630 LDKCOption_OffersMessageZ self;
6632 COption_OffersMessageZ(const COption_OffersMessageZ&) = delete;
6633 COption_OffersMessageZ(COption_OffersMessageZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OffersMessageZ)); }
6634 COption_OffersMessageZ(LDKCOption_OffersMessageZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OffersMessageZ)); }
6635 operator LDKCOption_OffersMessageZ() && { LDKCOption_OffersMessageZ res = self; memset(&self, 0, sizeof(LDKCOption_OffersMessageZ)); return res; }
6636 ~COption_OffersMessageZ() { COption_OffersMessageZ_free(self); }
6637 COption_OffersMessageZ& operator=(COption_OffersMessageZ&& o) { COption_OffersMessageZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OffersMessageZ)); return *this; }
6638 LDKCOption_OffersMessageZ* operator &() { return &self; }
6639 LDKCOption_OffersMessageZ* operator ->() { return &self; }
6640 const LDKCOption_OffersMessageZ* operator &() const { return &self; }
6641 const LDKCOption_OffersMessageZ* operator ->() const { return &self; }
6643 class CResult_CVec_u8ZPeerHandleErrorZ {
6645 LDKCResult_CVec_u8ZPeerHandleErrorZ self;
6647 CResult_CVec_u8ZPeerHandleErrorZ(const CResult_CVec_u8ZPeerHandleErrorZ&) = delete;
6648 CResult_CVec_u8ZPeerHandleErrorZ(CResult_CVec_u8ZPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZPeerHandleErrorZ)); }
6649 CResult_CVec_u8ZPeerHandleErrorZ(LDKCResult_CVec_u8ZPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); }
6650 operator LDKCResult_CVec_u8ZPeerHandleErrorZ() && { LDKCResult_CVec_u8ZPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ)); return res; }
6651 ~CResult_CVec_u8ZPeerHandleErrorZ() { CResult_CVec_u8ZPeerHandleErrorZ_free(self); }
6652 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; }
6653 LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() { return &self; }
6654 LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() { return &self; }
6655 const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator &() const { return &self; }
6656 const LDKCResult_CVec_u8ZPeerHandleErrorZ* operator ->() const { return &self; }
6658 class COption_NetworkUpdateZ {
6660 LDKCOption_NetworkUpdateZ self;
6662 COption_NetworkUpdateZ(const COption_NetworkUpdateZ&) = delete;
6663 COption_NetworkUpdateZ(COption_NetworkUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NetworkUpdateZ)); }
6664 COption_NetworkUpdateZ(LDKCOption_NetworkUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NetworkUpdateZ)); }
6665 operator LDKCOption_NetworkUpdateZ() && { LDKCOption_NetworkUpdateZ res = self; memset(&self, 0, sizeof(LDKCOption_NetworkUpdateZ)); return res; }
6666 ~COption_NetworkUpdateZ() { COption_NetworkUpdateZ_free(self); }
6667 COption_NetworkUpdateZ& operator=(COption_NetworkUpdateZ&& o) { COption_NetworkUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NetworkUpdateZ)); return *this; }
6668 LDKCOption_NetworkUpdateZ* operator &() { return &self; }
6669 LDKCOption_NetworkUpdateZ* operator ->() { return &self; }
6670 const LDKCOption_NetworkUpdateZ* operator &() const { return &self; }
6671 const LDKCOption_NetworkUpdateZ* operator ->() const { return &self; }
6673 class COption_u64Z {
6675 LDKCOption_u64Z self;
6677 COption_u64Z(const COption_u64Z&) = delete;
6678 COption_u64Z(COption_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u64Z)); }
6679 COption_u64Z(LDKCOption_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u64Z)); }
6680 operator LDKCOption_u64Z() && { LDKCOption_u64Z res = self; memset(&self, 0, sizeof(LDKCOption_u64Z)); return res; }
6681 ~COption_u64Z() { COption_u64Z_free(self); }
6682 COption_u64Z& operator=(COption_u64Z&& o) { COption_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u64Z)); return *this; }
6683 LDKCOption_u64Z* operator &() { return &self; }
6684 LDKCOption_u64Z* operator ->() { return &self; }
6685 const LDKCOption_u64Z* operator &() const { return &self; }
6686 const LDKCOption_u64Z* operator ->() const { return &self; }
6688 class CResult_OnionPacketDecodeErrorZ {
6690 LDKCResult_OnionPacketDecodeErrorZ self;
6692 CResult_OnionPacketDecodeErrorZ(const CResult_OnionPacketDecodeErrorZ&) = delete;
6693 CResult_OnionPacketDecodeErrorZ(CResult_OnionPacketDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); }
6694 CResult_OnionPacketDecodeErrorZ(LDKCResult_OnionPacketDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); }
6695 operator LDKCResult_OnionPacketDecodeErrorZ() && { LDKCResult_OnionPacketDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionPacketDecodeErrorZ)); return res; }
6696 ~CResult_OnionPacketDecodeErrorZ() { CResult_OnionPacketDecodeErrorZ_free(self); }
6697 CResult_OnionPacketDecodeErrorZ& operator=(CResult_OnionPacketDecodeErrorZ&& o) { CResult_OnionPacketDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionPacketDecodeErrorZ)); return *this; }
6698 LDKCResult_OnionPacketDecodeErrorZ* operator &() { return &self; }
6699 LDKCResult_OnionPacketDecodeErrorZ* operator ->() { return &self; }
6700 const LDKCResult_OnionPacketDecodeErrorZ* operator &() const { return &self; }
6701 const LDKCResult_OnionPacketDecodeErrorZ* operator ->() const { return &self; }
6703 class CResult_GossipTimestampFilterDecodeErrorZ {
6705 LDKCResult_GossipTimestampFilterDecodeErrorZ self;
6707 CResult_GossipTimestampFilterDecodeErrorZ(const CResult_GossipTimestampFilterDecodeErrorZ&) = delete;
6708 CResult_GossipTimestampFilterDecodeErrorZ(CResult_GossipTimestampFilterDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); }
6709 CResult_GossipTimestampFilterDecodeErrorZ(LDKCResult_GossipTimestampFilterDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); }
6710 operator LDKCResult_GossipTimestampFilterDecodeErrorZ() && { LDKCResult_GossipTimestampFilterDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ)); return res; }
6711 ~CResult_GossipTimestampFilterDecodeErrorZ() { CResult_GossipTimestampFilterDecodeErrorZ_free(self); }
6712 CResult_GossipTimestampFilterDecodeErrorZ& operator=(CResult_GossipTimestampFilterDecodeErrorZ&& o) { CResult_GossipTimestampFilterDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_GossipTimestampFilterDecodeErrorZ)); return *this; }
6713 LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() { return &self; }
6714 LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() { return &self; }
6715 const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator &() const { return &self; }
6716 const LDKCResult_GossipTimestampFilterDecodeErrorZ* operator ->() const { return &self; }
6718 class CResult_RouteHintDecodeErrorZ {
6720 LDKCResult_RouteHintDecodeErrorZ self;
6722 CResult_RouteHintDecodeErrorZ(const CResult_RouteHintDecodeErrorZ&) = delete;
6723 CResult_RouteHintDecodeErrorZ(CResult_RouteHintDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); }
6724 CResult_RouteHintDecodeErrorZ(LDKCResult_RouteHintDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); }
6725 operator LDKCResult_RouteHintDecodeErrorZ() && { LDKCResult_RouteHintDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintDecodeErrorZ)); return res; }
6726 ~CResult_RouteHintDecodeErrorZ() { CResult_RouteHintDecodeErrorZ_free(self); }
6727 CResult_RouteHintDecodeErrorZ& operator=(CResult_RouteHintDecodeErrorZ&& o) { CResult_RouteHintDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintDecodeErrorZ)); return *this; }
6728 LDKCResult_RouteHintDecodeErrorZ* operator &() { return &self; }
6729 LDKCResult_RouteHintDecodeErrorZ* operator ->() { return &self; }
6730 const LDKCResult_RouteHintDecodeErrorZ* operator &() const { return &self; }
6731 const LDKCResult_RouteHintDecodeErrorZ* operator ->() const { return &self; }
6733 class COption_FilterZ {
6735 LDKCOption_FilterZ self;
6737 COption_FilterZ(const COption_FilterZ&) = delete;
6738 COption_FilterZ(COption_FilterZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_FilterZ)); }
6739 COption_FilterZ(LDKCOption_FilterZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_FilterZ)); }
6740 operator LDKCOption_FilterZ() && { LDKCOption_FilterZ res = self; memset(&self, 0, sizeof(LDKCOption_FilterZ)); return res; }
6741 ~COption_FilterZ() { COption_FilterZ_free(self); }
6742 COption_FilterZ& operator=(COption_FilterZ&& o) { COption_FilterZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_FilterZ)); return *this; }
6743 LDKCOption_FilterZ* operator &() { return &self; }
6744 LDKCOption_FilterZ* operator ->() { return &self; }
6745 const LDKCOption_FilterZ* operator &() const { return &self; }
6746 const LDKCOption_FilterZ* operator ->() const { return &self; }
6748 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ {
6750 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ self;
6752 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&) = delete;
6753 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); }
6754 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)); }
6755 operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ)); return res; }
6756 ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(self); }
6757 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; }
6758 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() { return &self; }
6759 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() { return &self; }
6760 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator &() const { return &self; }
6761 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* operator ->() const { return &self; }
6763 class COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ {
6765 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ self;
6767 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(const COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&) = delete;
6768 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6769 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); }
6770 operator LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() && { LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ res = self; memset(&self, 0, sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ)); return res; }
6771 ~COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ() { COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(self); }
6772 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; }
6773 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() { return &self; }
6774 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() { return &self; }
6775 const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator &() const { return &self; }
6776 const LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* operator ->() const { return &self; }
6778 class CResult_COption_APIErrorZDecodeErrorZ {
6780 LDKCResult_COption_APIErrorZDecodeErrorZ self;
6782 CResult_COption_APIErrorZDecodeErrorZ(const CResult_COption_APIErrorZDecodeErrorZ&) = delete;
6783 CResult_COption_APIErrorZDecodeErrorZ(CResult_COption_APIErrorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_APIErrorZDecodeErrorZ)); }
6784 CResult_COption_APIErrorZDecodeErrorZ(LDKCResult_COption_APIErrorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); }
6785 operator LDKCResult_COption_APIErrorZDecodeErrorZ() && { LDKCResult_COption_APIErrorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ)); return res; }
6786 ~CResult_COption_APIErrorZDecodeErrorZ() { CResult_COption_APIErrorZDecodeErrorZ_free(self); }
6787 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; }
6788 LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() { return &self; }
6789 LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() { return &self; }
6790 const LDKCResult_COption_APIErrorZDecodeErrorZ* operator &() const { return &self; }
6791 const LDKCResult_COption_APIErrorZDecodeErrorZ* operator ->() const { return &self; }
6793 class CVec_UpdateAddHTLCZ {
6795 LDKCVec_UpdateAddHTLCZ self;
6797 CVec_UpdateAddHTLCZ(const CVec_UpdateAddHTLCZ&) = delete;
6798 CVec_UpdateAddHTLCZ(CVec_UpdateAddHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); }
6799 CVec_UpdateAddHTLCZ(LDKCVec_UpdateAddHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); }
6800 operator LDKCVec_UpdateAddHTLCZ() && { LDKCVec_UpdateAddHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateAddHTLCZ)); return res; }
6801 ~CVec_UpdateAddHTLCZ() { CVec_UpdateAddHTLCZ_free(self); }
6802 CVec_UpdateAddHTLCZ& operator=(CVec_UpdateAddHTLCZ&& o) { CVec_UpdateAddHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateAddHTLCZ)); return *this; }
6803 LDKCVec_UpdateAddHTLCZ* operator &() { return &self; }
6804 LDKCVec_UpdateAddHTLCZ* operator ->() { return &self; }
6805 const LDKCVec_UpdateAddHTLCZ* operator &() const { return &self; }
6806 const LDKCVec_UpdateAddHTLCZ* operator ->() const { return &self; }
6808 class CResult_TxAbortDecodeErrorZ {
6810 LDKCResult_TxAbortDecodeErrorZ self;
6812 CResult_TxAbortDecodeErrorZ(const CResult_TxAbortDecodeErrorZ&) = delete;
6813 CResult_TxAbortDecodeErrorZ(CResult_TxAbortDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); }
6814 CResult_TxAbortDecodeErrorZ(LDKCResult_TxAbortDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); }
6815 operator LDKCResult_TxAbortDecodeErrorZ() && { LDKCResult_TxAbortDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAbortDecodeErrorZ)); return res; }
6816 ~CResult_TxAbortDecodeErrorZ() { CResult_TxAbortDecodeErrorZ_free(self); }
6817 CResult_TxAbortDecodeErrorZ& operator=(CResult_TxAbortDecodeErrorZ&& o) { CResult_TxAbortDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAbortDecodeErrorZ)); return *this; }
6818 LDKCResult_TxAbortDecodeErrorZ* operator &() { return &self; }
6819 LDKCResult_TxAbortDecodeErrorZ* operator ->() { return &self; }
6820 const LDKCResult_TxAbortDecodeErrorZ* operator &() const { return &self; }
6821 const LDKCResult_TxAbortDecodeErrorZ* operator ->() const { return &self; }
6823 class CResult_StaticPaymentOutputDescriptorDecodeErrorZ {
6825 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ self;
6827 CResult_StaticPaymentOutputDescriptorDecodeErrorZ(const CResult_StaticPaymentOutputDescriptorDecodeErrorZ&) = delete;
6828 CResult_StaticPaymentOutputDescriptorDecodeErrorZ(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6829 CResult_StaticPaymentOutputDescriptorDecodeErrorZ(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); }
6830 operator LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return res; }
6831 ~CResult_StaticPaymentOutputDescriptorDecodeErrorZ() { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); }
6832 CResult_StaticPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_StaticPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StaticPaymentOutputDescriptorDecodeErrorZ)); return *this; }
6833 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
6834 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
6835 const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
6836 const LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
6838 class COption_u32Z {
6840 LDKCOption_u32Z self;
6842 COption_u32Z(const COption_u32Z&) = delete;
6843 COption_u32Z(COption_u32Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u32Z)); }
6844 COption_u32Z(LDKCOption_u32Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u32Z)); }
6845 operator LDKCOption_u32Z() && { LDKCOption_u32Z res = self; memset(&self, 0, sizeof(LDKCOption_u32Z)); return res; }
6846 ~COption_u32Z() { COption_u32Z_free(self); }
6847 COption_u32Z& operator=(COption_u32Z&& o) { COption_u32Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u32Z)); return *this; }
6848 LDKCOption_u32Z* operator &() { return &self; }
6849 LDKCOption_u32Z* operator ->() { return &self; }
6850 const LDKCOption_u32Z* operator &() const { return &self; }
6851 const LDKCOption_u32Z* operator ->() const { return &self; }
6853 class CResult_RecipientOnionFieldsNoneZ {
6855 LDKCResult_RecipientOnionFieldsNoneZ self;
6857 CResult_RecipientOnionFieldsNoneZ(const CResult_RecipientOnionFieldsNoneZ&) = delete;
6858 CResult_RecipientOnionFieldsNoneZ(CResult_RecipientOnionFieldsNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); }
6859 CResult_RecipientOnionFieldsNoneZ(LDKCResult_RecipientOnionFieldsNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); }
6860 operator LDKCResult_RecipientOnionFieldsNoneZ() && { LDKCResult_RecipientOnionFieldsNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsNoneZ)); return res; }
6861 ~CResult_RecipientOnionFieldsNoneZ() { CResult_RecipientOnionFieldsNoneZ_free(self); }
6862 CResult_RecipientOnionFieldsNoneZ& operator=(CResult_RecipientOnionFieldsNoneZ&& o) { CResult_RecipientOnionFieldsNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsNoneZ)); return *this; }
6863 LDKCResult_RecipientOnionFieldsNoneZ* operator &() { return &self; }
6864 LDKCResult_RecipientOnionFieldsNoneZ* operator ->() { return &self; }
6865 const LDKCResult_RecipientOnionFieldsNoneZ* operator &() const { return &self; }
6866 const LDKCResult_RecipientOnionFieldsNoneZ* operator ->() const { return &self; }
6868 class C2Tuple__u1632_u1632Z {
6870 LDKC2Tuple__u1632_u1632Z self;
6872 C2Tuple__u1632_u1632Z(const C2Tuple__u1632_u1632Z&) = delete;
6873 C2Tuple__u1632_u1632Z(C2Tuple__u1632_u1632Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u1632_u1632Z)); }
6874 C2Tuple__u1632_u1632Z(LDKC2Tuple__u1632_u1632Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); }
6875 operator LDKC2Tuple__u1632_u1632Z() && { LDKC2Tuple__u1632_u1632Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u1632_u1632Z)); return res; }
6876 ~C2Tuple__u1632_u1632Z() { C2Tuple__u1632_u1632Z_free(self); }
6877 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; }
6878 LDKC2Tuple__u1632_u1632Z* operator &() { return &self; }
6879 LDKC2Tuple__u1632_u1632Z* operator ->() { return &self; }
6880 const LDKC2Tuple__u1632_u1632Z* operator &() const { return &self; }
6881 const LDKC2Tuple__u1632_u1632Z* operator ->() const { return &self; }
6883 class CResult_CVec_StrZIOErrorZ {
6885 LDKCResult_CVec_StrZIOErrorZ self;
6887 CResult_CVec_StrZIOErrorZ(const CResult_CVec_StrZIOErrorZ&) = delete;
6888 CResult_CVec_StrZIOErrorZ(CResult_CVec_StrZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_StrZIOErrorZ)); }
6889 CResult_CVec_StrZIOErrorZ(LDKCResult_CVec_StrZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); }
6890 operator LDKCResult_CVec_StrZIOErrorZ() && { LDKCResult_CVec_StrZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_StrZIOErrorZ)); return res; }
6891 ~CResult_CVec_StrZIOErrorZ() { CResult_CVec_StrZIOErrorZ_free(self); }
6892 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; }
6893 LDKCResult_CVec_StrZIOErrorZ* operator &() { return &self; }
6894 LDKCResult_CVec_StrZIOErrorZ* operator ->() { return &self; }
6895 const LDKCResult_CVec_StrZIOErrorZ* operator &() const { return &self; }
6896 const LDKCResult_CVec_StrZIOErrorZ* operator ->() const { return &self; }
6898 class CResult_ClosingSignedFeeRangeDecodeErrorZ {
6900 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ self;
6902 CResult_ClosingSignedFeeRangeDecodeErrorZ(const CResult_ClosingSignedFeeRangeDecodeErrorZ&) = delete;
6903 CResult_ClosingSignedFeeRangeDecodeErrorZ(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6904 CResult_ClosingSignedFeeRangeDecodeErrorZ(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); }
6905 operator LDKCResult_ClosingSignedFeeRangeDecodeErrorZ() && { LDKCResult_ClosingSignedFeeRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ)); return res; }
6906 ~CResult_ClosingSignedFeeRangeDecodeErrorZ() { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); }
6907 CResult_ClosingSignedFeeRangeDecodeErrorZ& operator=(CResult_ClosingSignedFeeRangeDecodeErrorZ&& o) { CResult_ClosingSignedFeeRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedFeeRangeDecodeErrorZ)); return *this; }
6908 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() { return &self; }
6909 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() { return &self; }
6910 const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator &() const { return &self; }
6911 const LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* operator ->() const { return &self; }
6913 class CResult_TransactionNoneZ {
6915 LDKCResult_TransactionNoneZ self;
6917 CResult_TransactionNoneZ(const CResult_TransactionNoneZ&) = delete;
6918 CResult_TransactionNoneZ(CResult_TransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionNoneZ)); }
6919 CResult_TransactionNoneZ(LDKCResult_TransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionNoneZ)); }
6920 operator LDKCResult_TransactionNoneZ() && { LDKCResult_TransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionNoneZ)); return res; }
6921 ~CResult_TransactionNoneZ() { CResult_TransactionNoneZ_free(self); }
6922 CResult_TransactionNoneZ& operator=(CResult_TransactionNoneZ&& o) { CResult_TransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionNoneZ)); return *this; }
6923 LDKCResult_TransactionNoneZ* operator &() { return &self; }
6924 LDKCResult_TransactionNoneZ* operator ->() { return &self; }
6925 const LDKCResult_TransactionNoneZ* operator &() const { return &self; }
6926 const LDKCResult_TransactionNoneZ* operator ->() const { return &self; }
6928 class CResult_CommitmentSignedDecodeErrorZ {
6930 LDKCResult_CommitmentSignedDecodeErrorZ self;
6932 CResult_CommitmentSignedDecodeErrorZ(const CResult_CommitmentSignedDecodeErrorZ&) = delete;
6933 CResult_CommitmentSignedDecodeErrorZ(CResult_CommitmentSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); }
6934 CResult_CommitmentSignedDecodeErrorZ(LDKCResult_CommitmentSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); }
6935 operator LDKCResult_CommitmentSignedDecodeErrorZ() && { LDKCResult_CommitmentSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentSignedDecodeErrorZ)); return res; }
6936 ~CResult_CommitmentSignedDecodeErrorZ() { CResult_CommitmentSignedDecodeErrorZ_free(self); }
6937 CResult_CommitmentSignedDecodeErrorZ& operator=(CResult_CommitmentSignedDecodeErrorZ&& o) { CResult_CommitmentSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentSignedDecodeErrorZ)); return *this; }
6938 LDKCResult_CommitmentSignedDecodeErrorZ* operator &() { return &self; }
6939 LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() { return &self; }
6940 const LDKCResult_CommitmentSignedDecodeErrorZ* operator &() const { return &self; }
6941 const LDKCResult_CommitmentSignedDecodeErrorZ* operator ->() const { return &self; }
6943 class CResult_CommitmentTransactionDecodeErrorZ {
6945 LDKCResult_CommitmentTransactionDecodeErrorZ self;
6947 CResult_CommitmentTransactionDecodeErrorZ(const CResult_CommitmentTransactionDecodeErrorZ&) = delete;
6948 CResult_CommitmentTransactionDecodeErrorZ(CResult_CommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); }
6949 CResult_CommitmentTransactionDecodeErrorZ(LDKCResult_CommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); }
6950 operator LDKCResult_CommitmentTransactionDecodeErrorZ() && { LDKCResult_CommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ)); return res; }
6951 ~CResult_CommitmentTransactionDecodeErrorZ() { CResult_CommitmentTransactionDecodeErrorZ_free(self); }
6952 CResult_CommitmentTransactionDecodeErrorZ& operator=(CResult_CommitmentTransactionDecodeErrorZ&& o) { CResult_CommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CommitmentTransactionDecodeErrorZ)); return *this; }
6953 LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() { return &self; }
6954 LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
6955 const LDKCResult_CommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
6956 const LDKCResult_CommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
6958 class CResult_StfuDecodeErrorZ {
6960 LDKCResult_StfuDecodeErrorZ self;
6962 CResult_StfuDecodeErrorZ(const CResult_StfuDecodeErrorZ&) = delete;
6963 CResult_StfuDecodeErrorZ(CResult_StfuDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); }
6964 CResult_StfuDecodeErrorZ(LDKCResult_StfuDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); }
6965 operator LDKCResult_StfuDecodeErrorZ() && { LDKCResult_StfuDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StfuDecodeErrorZ)); return res; }
6966 ~CResult_StfuDecodeErrorZ() { CResult_StfuDecodeErrorZ_free(self); }
6967 CResult_StfuDecodeErrorZ& operator=(CResult_StfuDecodeErrorZ&& o) { CResult_StfuDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StfuDecodeErrorZ)); return *this; }
6968 LDKCResult_StfuDecodeErrorZ* operator &() { return &self; }
6969 LDKCResult_StfuDecodeErrorZ* operator ->() { return &self; }
6970 const LDKCResult_StfuDecodeErrorZ* operator &() const { return &self; }
6971 const LDKCResult_StfuDecodeErrorZ* operator ->() const { return &self; }
6973 class CResult_OpenChannelDecodeErrorZ {
6975 LDKCResult_OpenChannelDecodeErrorZ self;
6977 CResult_OpenChannelDecodeErrorZ(const CResult_OpenChannelDecodeErrorZ&) = delete;
6978 CResult_OpenChannelDecodeErrorZ(CResult_OpenChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); }
6979 CResult_OpenChannelDecodeErrorZ(LDKCResult_OpenChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); }
6980 operator LDKCResult_OpenChannelDecodeErrorZ() && { LDKCResult_OpenChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelDecodeErrorZ)); return res; }
6981 ~CResult_OpenChannelDecodeErrorZ() { CResult_OpenChannelDecodeErrorZ_free(self); }
6982 CResult_OpenChannelDecodeErrorZ& operator=(CResult_OpenChannelDecodeErrorZ&& o) { CResult_OpenChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelDecodeErrorZ)); return *this; }
6983 LDKCResult_OpenChannelDecodeErrorZ* operator &() { return &self; }
6984 LDKCResult_OpenChannelDecodeErrorZ* operator ->() { return &self; }
6985 const LDKCResult_OpenChannelDecodeErrorZ* operator &() const { return &self; }
6986 const LDKCResult_OpenChannelDecodeErrorZ* operator ->() const { return &self; }
6988 class CResult_ErrorMessageDecodeErrorZ {
6990 LDKCResult_ErrorMessageDecodeErrorZ self;
6992 CResult_ErrorMessageDecodeErrorZ(const CResult_ErrorMessageDecodeErrorZ&) = delete;
6993 CResult_ErrorMessageDecodeErrorZ(CResult_ErrorMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); }
6994 CResult_ErrorMessageDecodeErrorZ(LDKCResult_ErrorMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); }
6995 operator LDKCResult_ErrorMessageDecodeErrorZ() && { LDKCResult_ErrorMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ErrorMessageDecodeErrorZ)); return res; }
6996 ~CResult_ErrorMessageDecodeErrorZ() { CResult_ErrorMessageDecodeErrorZ_free(self); }
6997 CResult_ErrorMessageDecodeErrorZ& operator=(CResult_ErrorMessageDecodeErrorZ&& o) { CResult_ErrorMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ErrorMessageDecodeErrorZ)); return *this; }
6998 LDKCResult_ErrorMessageDecodeErrorZ* operator &() { return &self; }
6999 LDKCResult_ErrorMessageDecodeErrorZ* operator ->() { return &self; }
7000 const LDKCResult_ErrorMessageDecodeErrorZ* operator &() const { return &self; }
7001 const LDKCResult_ErrorMessageDecodeErrorZ* operator ->() const { return &self; }
7003 class COption_APIErrorZ {
7005 LDKCOption_APIErrorZ self;
7007 COption_APIErrorZ(const COption_APIErrorZ&) = delete;
7008 COption_APIErrorZ(COption_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_APIErrorZ)); }
7009 COption_APIErrorZ(LDKCOption_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_APIErrorZ)); }
7010 operator LDKCOption_APIErrorZ() && { LDKCOption_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCOption_APIErrorZ)); return res; }
7011 ~COption_APIErrorZ() { COption_APIErrorZ_free(self); }
7012 COption_APIErrorZ& operator=(COption_APIErrorZ&& o) { COption_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_APIErrorZ)); return *this; }
7013 LDKCOption_APIErrorZ* operator &() { return &self; }
7014 LDKCOption_APIErrorZ* operator ->() { return &self; }
7015 const LDKCOption_APIErrorZ* operator &() const { return &self; }
7016 const LDKCOption_APIErrorZ* operator ->() const { return &self; }
7018 class CResult_QueryChannelRangeDecodeErrorZ {
7020 LDKCResult_QueryChannelRangeDecodeErrorZ self;
7022 CResult_QueryChannelRangeDecodeErrorZ(const CResult_QueryChannelRangeDecodeErrorZ&) = delete;
7023 CResult_QueryChannelRangeDecodeErrorZ(CResult_QueryChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); }
7024 CResult_QueryChannelRangeDecodeErrorZ(LDKCResult_QueryChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); }
7025 operator LDKCResult_QueryChannelRangeDecodeErrorZ() && { LDKCResult_QueryChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ)); return res; }
7026 ~CResult_QueryChannelRangeDecodeErrorZ() { CResult_QueryChannelRangeDecodeErrorZ_free(self); }
7027 CResult_QueryChannelRangeDecodeErrorZ& operator=(CResult_QueryChannelRangeDecodeErrorZ&& o) { CResult_QueryChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryChannelRangeDecodeErrorZ)); return *this; }
7028 LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() { return &self; }
7029 LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() { return &self; }
7030 const LDKCResult_QueryChannelRangeDecodeErrorZ* operator &() const { return &self; }
7031 const LDKCResult_QueryChannelRangeDecodeErrorZ* operator ->() const { return &self; }
7033 class CVec_TransactionZ {
7035 LDKCVec_TransactionZ self;
7037 CVec_TransactionZ(const CVec_TransactionZ&) = delete;
7038 CVec_TransactionZ(CVec_TransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionZ)); }
7039 CVec_TransactionZ(LDKCVec_TransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionZ)); }
7040 operator LDKCVec_TransactionZ() && { LDKCVec_TransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionZ)); return res; }
7041 ~CVec_TransactionZ() { CVec_TransactionZ_free(self); }
7042 CVec_TransactionZ& operator=(CVec_TransactionZ&& o) { CVec_TransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionZ)); return *this; }
7043 LDKCVec_TransactionZ* operator &() { return &self; }
7044 LDKCVec_TransactionZ* operator ->() { return &self; }
7045 const LDKCVec_TransactionZ* operator &() const { return &self; }
7046 const LDKCVec_TransactionZ* operator ->() const { return &self; }
7050 LDKCVec_InputZ self;
7052 CVec_InputZ(const CVec_InputZ&) = delete;
7053 CVec_InputZ(CVec_InputZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_InputZ)); }
7054 CVec_InputZ(LDKCVec_InputZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_InputZ)); }
7055 operator LDKCVec_InputZ() && { LDKCVec_InputZ res = self; memset(&self, 0, sizeof(LDKCVec_InputZ)); return res; }
7056 ~CVec_InputZ() { CVec_InputZ_free(self); }
7057 CVec_InputZ& operator=(CVec_InputZ&& o) { CVec_InputZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_InputZ)); return *this; }
7058 LDKCVec_InputZ* operator &() { return &self; }
7059 LDKCVec_InputZ* operator ->() { return &self; }
7060 const LDKCVec_InputZ* operator &() const { return &self; }
7061 const LDKCVec_InputZ* operator ->() const { return &self; }
7063 class CResult_ChannelFeaturesDecodeErrorZ {
7065 LDKCResult_ChannelFeaturesDecodeErrorZ self;
7067 CResult_ChannelFeaturesDecodeErrorZ(const CResult_ChannelFeaturesDecodeErrorZ&) = delete;
7068 CResult_ChannelFeaturesDecodeErrorZ(CResult_ChannelFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); }
7069 CResult_ChannelFeaturesDecodeErrorZ(LDKCResult_ChannelFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); }
7070 operator LDKCResult_ChannelFeaturesDecodeErrorZ() && { LDKCResult_ChannelFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ)); return res; }
7071 ~CResult_ChannelFeaturesDecodeErrorZ() { CResult_ChannelFeaturesDecodeErrorZ_free(self); }
7072 CResult_ChannelFeaturesDecodeErrorZ& operator=(CResult_ChannelFeaturesDecodeErrorZ&& o) { CResult_ChannelFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelFeaturesDecodeErrorZ)); return *this; }
7073 LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() { return &self; }
7074 LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() { return &self; }
7075 const LDKCResult_ChannelFeaturesDecodeErrorZ* operator &() const { return &self; }
7076 const LDKCResult_ChannelFeaturesDecodeErrorZ* operator ->() const { return &self; }
7078 class CResult_ChannelReadyDecodeErrorZ {
7080 LDKCResult_ChannelReadyDecodeErrorZ self;
7082 CResult_ChannelReadyDecodeErrorZ(const CResult_ChannelReadyDecodeErrorZ&) = delete;
7083 CResult_ChannelReadyDecodeErrorZ(CResult_ChannelReadyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); }
7084 CResult_ChannelReadyDecodeErrorZ(LDKCResult_ChannelReadyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); }
7085 operator LDKCResult_ChannelReadyDecodeErrorZ() && { LDKCResult_ChannelReadyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReadyDecodeErrorZ)); return res; }
7086 ~CResult_ChannelReadyDecodeErrorZ() { CResult_ChannelReadyDecodeErrorZ_free(self); }
7087 CResult_ChannelReadyDecodeErrorZ& operator=(CResult_ChannelReadyDecodeErrorZ&& o) { CResult_ChannelReadyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReadyDecodeErrorZ)); return *this; }
7088 LDKCResult_ChannelReadyDecodeErrorZ* operator &() { return &self; }
7089 LDKCResult_ChannelReadyDecodeErrorZ* operator ->() { return &self; }
7090 const LDKCResult_ChannelReadyDecodeErrorZ* operator &() const { return &self; }
7091 const LDKCResult_ChannelReadyDecodeErrorZ* operator ->() const { return &self; }
7093 class CResult_RevocationBasepointDecodeErrorZ {
7095 LDKCResult_RevocationBasepointDecodeErrorZ self;
7097 CResult_RevocationBasepointDecodeErrorZ(const CResult_RevocationBasepointDecodeErrorZ&) = delete;
7098 CResult_RevocationBasepointDecodeErrorZ(CResult_RevocationBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); }
7099 CResult_RevocationBasepointDecodeErrorZ(LDKCResult_RevocationBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); }
7100 operator LDKCResult_RevocationBasepointDecodeErrorZ() && { LDKCResult_RevocationBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationBasepointDecodeErrorZ)); return res; }
7101 ~CResult_RevocationBasepointDecodeErrorZ() { CResult_RevocationBasepointDecodeErrorZ_free(self); }
7102 CResult_RevocationBasepointDecodeErrorZ& operator=(CResult_RevocationBasepointDecodeErrorZ&& o) { CResult_RevocationBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationBasepointDecodeErrorZ)); return *this; }
7103 LDKCResult_RevocationBasepointDecodeErrorZ* operator &() { return &self; }
7104 LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() { return &self; }
7105 const LDKCResult_RevocationBasepointDecodeErrorZ* operator &() const { return &self; }
7106 const LDKCResult_RevocationBasepointDecodeErrorZ* operator ->() const { return &self; }
7108 class CResult_UpdateFeeDecodeErrorZ {
7110 LDKCResult_UpdateFeeDecodeErrorZ self;
7112 CResult_UpdateFeeDecodeErrorZ(const CResult_UpdateFeeDecodeErrorZ&) = delete;
7113 CResult_UpdateFeeDecodeErrorZ(CResult_UpdateFeeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); }
7114 CResult_UpdateFeeDecodeErrorZ(LDKCResult_UpdateFeeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); }
7115 operator LDKCResult_UpdateFeeDecodeErrorZ() && { LDKCResult_UpdateFeeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFeeDecodeErrorZ)); return res; }
7116 ~CResult_UpdateFeeDecodeErrorZ() { CResult_UpdateFeeDecodeErrorZ_free(self); }
7117 CResult_UpdateFeeDecodeErrorZ& operator=(CResult_UpdateFeeDecodeErrorZ&& o) { CResult_UpdateFeeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFeeDecodeErrorZ)); return *this; }
7118 LDKCResult_UpdateFeeDecodeErrorZ* operator &() { return &self; }
7119 LDKCResult_UpdateFeeDecodeErrorZ* operator ->() { return &self; }
7120 const LDKCResult_UpdateFeeDecodeErrorZ* operator &() const { return &self; }
7121 const LDKCResult_UpdateFeeDecodeErrorZ* operator ->() const { return &self; }
7123 class CResult_NoneBolt11SemanticErrorZ {
7125 LDKCResult_NoneBolt11SemanticErrorZ self;
7127 CResult_NoneBolt11SemanticErrorZ(const CResult_NoneBolt11SemanticErrorZ&) = delete;
7128 CResult_NoneBolt11SemanticErrorZ(CResult_NoneBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); }
7129 CResult_NoneBolt11SemanticErrorZ(LDKCResult_NoneBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); }
7130 operator LDKCResult_NoneBolt11SemanticErrorZ() && { LDKCResult_NoneBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt11SemanticErrorZ)); return res; }
7131 ~CResult_NoneBolt11SemanticErrorZ() { CResult_NoneBolt11SemanticErrorZ_free(self); }
7132 CResult_NoneBolt11SemanticErrorZ& operator=(CResult_NoneBolt11SemanticErrorZ&& o) { CResult_NoneBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt11SemanticErrorZ)); return *this; }
7133 LDKCResult_NoneBolt11SemanticErrorZ* operator &() { return &self; }
7134 LDKCResult_NoneBolt11SemanticErrorZ* operator ->() { return &self; }
7135 const LDKCResult_NoneBolt11SemanticErrorZ* operator &() const { return &self; }
7136 const LDKCResult_NoneBolt11SemanticErrorZ* operator ->() const { return &self; }
7138 class COption_OnionMessageContentsZ {
7140 LDKCOption_OnionMessageContentsZ self;
7142 COption_OnionMessageContentsZ(const COption_OnionMessageContentsZ&) = delete;
7143 COption_OnionMessageContentsZ(COption_OnionMessageContentsZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); }
7144 COption_OnionMessageContentsZ(LDKCOption_OnionMessageContentsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); }
7145 operator LDKCOption_OnionMessageContentsZ() && { LDKCOption_OnionMessageContentsZ res = self; memset(&self, 0, sizeof(LDKCOption_OnionMessageContentsZ)); return res; }
7146 ~COption_OnionMessageContentsZ() { COption_OnionMessageContentsZ_free(self); }
7147 COption_OnionMessageContentsZ& operator=(COption_OnionMessageContentsZ&& o) { COption_OnionMessageContentsZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_OnionMessageContentsZ)); return *this; }
7148 LDKCOption_OnionMessageContentsZ* operator &() { return &self; }
7149 LDKCOption_OnionMessageContentsZ* operator ->() { return &self; }
7150 const LDKCOption_OnionMessageContentsZ* operator &() const { return &self; }
7151 const LDKCOption_OnionMessageContentsZ* operator ->() const { return &self; }
7153 class CResult_NoneRetryableSendFailureZ {
7155 LDKCResult_NoneRetryableSendFailureZ self;
7157 CResult_NoneRetryableSendFailureZ(const CResult_NoneRetryableSendFailureZ&) = delete;
7158 CResult_NoneRetryableSendFailureZ(CResult_NoneRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); }
7159 CResult_NoneRetryableSendFailureZ(LDKCResult_NoneRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); }
7160 operator LDKCResult_NoneRetryableSendFailureZ() && { LDKCResult_NoneRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneRetryableSendFailureZ)); return res; }
7161 ~CResult_NoneRetryableSendFailureZ() { CResult_NoneRetryableSendFailureZ_free(self); }
7162 CResult_NoneRetryableSendFailureZ& operator=(CResult_NoneRetryableSendFailureZ&& o) { CResult_NoneRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneRetryableSendFailureZ)); return *this; }
7163 LDKCResult_NoneRetryableSendFailureZ* operator &() { return &self; }
7164 LDKCResult_NoneRetryableSendFailureZ* operator ->() { return &self; }
7165 const LDKCResult_NoneRetryableSendFailureZ* operator &() const { return &self; }
7166 const LDKCResult_NoneRetryableSendFailureZ* operator ->() const { return &self; }
7168 class CResult_boolLightningErrorZ {
7170 LDKCResult_boolLightningErrorZ self;
7172 CResult_boolLightningErrorZ(const CResult_boolLightningErrorZ&) = delete;
7173 CResult_boolLightningErrorZ(CResult_boolLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); }
7174 CResult_boolLightningErrorZ(LDKCResult_boolLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolLightningErrorZ)); }
7175 operator LDKCResult_boolLightningErrorZ() && { LDKCResult_boolLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolLightningErrorZ)); return res; }
7176 ~CResult_boolLightningErrorZ() { CResult_boolLightningErrorZ_free(self); }
7177 CResult_boolLightningErrorZ& operator=(CResult_boolLightningErrorZ&& o) { CResult_boolLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolLightningErrorZ)); return *this; }
7178 LDKCResult_boolLightningErrorZ* operator &() { return &self; }
7179 LDKCResult_boolLightningErrorZ* operator ->() { return &self; }
7180 const LDKCResult_boolLightningErrorZ* operator &() const { return &self; }
7181 const LDKCResult_boolLightningErrorZ* operator ->() const { return &self; }
7183 class CResult_NodeIdDecodeErrorZ {
7185 LDKCResult_NodeIdDecodeErrorZ self;
7187 CResult_NodeIdDecodeErrorZ(const CResult_NodeIdDecodeErrorZ&) = delete;
7188 CResult_NodeIdDecodeErrorZ(CResult_NodeIdDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); }
7189 CResult_NodeIdDecodeErrorZ(LDKCResult_NodeIdDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); }
7190 operator LDKCResult_NodeIdDecodeErrorZ() && { LDKCResult_NodeIdDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeIdDecodeErrorZ)); return res; }
7191 ~CResult_NodeIdDecodeErrorZ() { CResult_NodeIdDecodeErrorZ_free(self); }
7192 CResult_NodeIdDecodeErrorZ& operator=(CResult_NodeIdDecodeErrorZ&& o) { CResult_NodeIdDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeIdDecodeErrorZ)); return *this; }
7193 LDKCResult_NodeIdDecodeErrorZ* operator &() { return &self; }
7194 LDKCResult_NodeIdDecodeErrorZ* operator ->() { return &self; }
7195 const LDKCResult_NodeIdDecodeErrorZ* operator &() const { return &self; }
7196 const LDKCResult_NodeIdDecodeErrorZ* operator ->() const { return &self; }
7198 class CResult_ChannelShutdownStateDecodeErrorZ {
7200 LDKCResult_ChannelShutdownStateDecodeErrorZ self;
7202 CResult_ChannelShutdownStateDecodeErrorZ(const CResult_ChannelShutdownStateDecodeErrorZ&) = delete;
7203 CResult_ChannelShutdownStateDecodeErrorZ(CResult_ChannelShutdownStateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); }
7204 CResult_ChannelShutdownStateDecodeErrorZ(LDKCResult_ChannelShutdownStateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); }
7205 operator LDKCResult_ChannelShutdownStateDecodeErrorZ() && { LDKCResult_ChannelShutdownStateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ)); return res; }
7206 ~CResult_ChannelShutdownStateDecodeErrorZ() { CResult_ChannelShutdownStateDecodeErrorZ_free(self); }
7207 CResult_ChannelShutdownStateDecodeErrorZ& operator=(CResult_ChannelShutdownStateDecodeErrorZ&& o) { CResult_ChannelShutdownStateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelShutdownStateDecodeErrorZ)); return *this; }
7208 LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() { return &self; }
7209 LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() { return &self; }
7210 const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator &() const { return &self; }
7211 const LDKCResult_ChannelShutdownStateDecodeErrorZ* operator ->() const { return &self; }
7213 class CResult_HTLCOutputInCommitmentDecodeErrorZ {
7215 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ self;
7217 CResult_HTLCOutputInCommitmentDecodeErrorZ(const CResult_HTLCOutputInCommitmentDecodeErrorZ&) = delete;
7218 CResult_HTLCOutputInCommitmentDecodeErrorZ(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); }
7219 CResult_HTLCOutputInCommitmentDecodeErrorZ(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); }
7220 operator LDKCResult_HTLCOutputInCommitmentDecodeErrorZ() && { LDKCResult_HTLCOutputInCommitmentDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ)); return res; }
7221 ~CResult_HTLCOutputInCommitmentDecodeErrorZ() { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); }
7222 CResult_HTLCOutputInCommitmentDecodeErrorZ& operator=(CResult_HTLCOutputInCommitmentDecodeErrorZ&& o) { CResult_HTLCOutputInCommitmentDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCOutputInCommitmentDecodeErrorZ)); return *this; }
7223 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() { return &self; }
7224 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() { return &self; }
7225 const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator &() const { return &self; }
7226 const LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* operator ->() const { return &self; }
7228 class CResult_NodeAnnouncementInfoDecodeErrorZ {
7230 LDKCResult_NodeAnnouncementInfoDecodeErrorZ self;
7232 CResult_NodeAnnouncementInfoDecodeErrorZ(const CResult_NodeAnnouncementInfoDecodeErrorZ&) = delete;
7233 CResult_NodeAnnouncementInfoDecodeErrorZ(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); }
7234 CResult_NodeAnnouncementInfoDecodeErrorZ(LDKCResult_NodeAnnouncementInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); }
7235 operator LDKCResult_NodeAnnouncementInfoDecodeErrorZ() && { LDKCResult_NodeAnnouncementInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ)); return res; }
7236 ~CResult_NodeAnnouncementInfoDecodeErrorZ() { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); }
7237 CResult_NodeAnnouncementInfoDecodeErrorZ& operator=(CResult_NodeAnnouncementInfoDecodeErrorZ&& o) { CResult_NodeAnnouncementInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementInfoDecodeErrorZ)); return *this; }
7238 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() { return &self; }
7239 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() { return &self; }
7240 const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator &() const { return &self; }
7241 const LDKCResult_NodeAnnouncementInfoDecodeErrorZ* operator ->() const { return &self; }
7243 class CResult_ShutdownScriptInvalidShutdownScriptZ {
7245 LDKCResult_ShutdownScriptInvalidShutdownScriptZ self;
7247 CResult_ShutdownScriptInvalidShutdownScriptZ(const CResult_ShutdownScriptInvalidShutdownScriptZ&) = delete;
7248 CResult_ShutdownScriptInvalidShutdownScriptZ(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); }
7249 CResult_ShutdownScriptInvalidShutdownScriptZ(LDKCResult_ShutdownScriptInvalidShutdownScriptZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); }
7250 operator LDKCResult_ShutdownScriptInvalidShutdownScriptZ() && { LDKCResult_ShutdownScriptInvalidShutdownScriptZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ)); return res; }
7251 ~CResult_ShutdownScriptInvalidShutdownScriptZ() { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); }
7252 CResult_ShutdownScriptInvalidShutdownScriptZ& operator=(CResult_ShutdownScriptInvalidShutdownScriptZ&& o) { CResult_ShutdownScriptInvalidShutdownScriptZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptInvalidShutdownScriptZ)); return *this; }
7253 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() { return &self; }
7254 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() { return &self; }
7255 const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator &() const { return &self; }
7256 const LDKCResult_ShutdownScriptInvalidShutdownScriptZ* operator ->() const { return &self; }
7258 class CResult_COption_NetworkUpdateZDecodeErrorZ {
7260 LDKCResult_COption_NetworkUpdateZDecodeErrorZ self;
7262 CResult_COption_NetworkUpdateZDecodeErrorZ(const CResult_COption_NetworkUpdateZDecodeErrorZ&) = delete;
7263 CResult_COption_NetworkUpdateZDecodeErrorZ(CResult_COption_NetworkUpdateZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_NetworkUpdateZDecodeErrorZ)); }
7264 CResult_COption_NetworkUpdateZDecodeErrorZ(LDKCResult_COption_NetworkUpdateZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); }
7265 operator LDKCResult_COption_NetworkUpdateZDecodeErrorZ() && { LDKCResult_COption_NetworkUpdateZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ)); return res; }
7266 ~CResult_COption_NetworkUpdateZDecodeErrorZ() { CResult_COption_NetworkUpdateZDecodeErrorZ_free(self); }
7267 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; }
7268 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() { return &self; }
7269 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() { return &self; }
7270 const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator &() const { return &self; }
7271 const LDKCResult_COption_NetworkUpdateZDecodeErrorZ* operator ->() const { return &self; }
7273 class CVec_UpdateFailMalformedHTLCZ {
7275 LDKCVec_UpdateFailMalformedHTLCZ self;
7277 CVec_UpdateFailMalformedHTLCZ(const CVec_UpdateFailMalformedHTLCZ&) = delete;
7278 CVec_UpdateFailMalformedHTLCZ(CVec_UpdateFailMalformedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); }
7279 CVec_UpdateFailMalformedHTLCZ(LDKCVec_UpdateFailMalformedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); }
7280 operator LDKCVec_UpdateFailMalformedHTLCZ() && { LDKCVec_UpdateFailMalformedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailMalformedHTLCZ)); return res; }
7281 ~CVec_UpdateFailMalformedHTLCZ() { CVec_UpdateFailMalformedHTLCZ_free(self); }
7282 CVec_UpdateFailMalformedHTLCZ& operator=(CVec_UpdateFailMalformedHTLCZ&& o) { CVec_UpdateFailMalformedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailMalformedHTLCZ)); return *this; }
7283 LDKCVec_UpdateFailMalformedHTLCZ* operator &() { return &self; }
7284 LDKCVec_UpdateFailMalformedHTLCZ* operator ->() { return &self; }
7285 const LDKCVec_UpdateFailMalformedHTLCZ* operator &() const { return &self; }
7286 const LDKCVec_UpdateFailMalformedHTLCZ* operator ->() const { return &self; }
7288 class CResult_ShutdownScriptNoneZ {
7290 LDKCResult_ShutdownScriptNoneZ self;
7292 CResult_ShutdownScriptNoneZ(const CResult_ShutdownScriptNoneZ&) = delete;
7293 CResult_ShutdownScriptNoneZ(CResult_ShutdownScriptNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); }
7294 CResult_ShutdownScriptNoneZ(LDKCResult_ShutdownScriptNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); }
7295 operator LDKCResult_ShutdownScriptNoneZ() && { LDKCResult_ShutdownScriptNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptNoneZ)); return res; }
7296 ~CResult_ShutdownScriptNoneZ() { CResult_ShutdownScriptNoneZ_free(self); }
7297 CResult_ShutdownScriptNoneZ& operator=(CResult_ShutdownScriptNoneZ&& o) { CResult_ShutdownScriptNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptNoneZ)); return *this; }
7298 LDKCResult_ShutdownScriptNoneZ* operator &() { return &self; }
7299 LDKCResult_ShutdownScriptNoneZ* operator ->() { return &self; }
7300 const LDKCResult_ShutdownScriptNoneZ* operator &() const { return &self; }
7301 const LDKCResult_ShutdownScriptNoneZ* operator ->() const { return &self; }
7303 class CResult_PendingHTLCInfoInboundHTLCErrZ {
7305 LDKCResult_PendingHTLCInfoInboundHTLCErrZ self;
7307 CResult_PendingHTLCInfoInboundHTLCErrZ(const CResult_PendingHTLCInfoInboundHTLCErrZ&) = delete;
7308 CResult_PendingHTLCInfoInboundHTLCErrZ(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); }
7309 CResult_PendingHTLCInfoInboundHTLCErrZ(LDKCResult_PendingHTLCInfoInboundHTLCErrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); }
7310 operator LDKCResult_PendingHTLCInfoInboundHTLCErrZ() && { LDKCResult_PendingHTLCInfoInboundHTLCErrZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoInboundHTLCErrZ)); return res; }
7311 ~CResult_PendingHTLCInfoInboundHTLCErrZ() { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); }
7312 CResult_PendingHTLCInfoInboundHTLCErrZ& operator=(CResult_PendingHTLCInfoInboundHTLCErrZ&& o) { CResult_PendingHTLCInfoInboundHTLCErrZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoInboundHTLCErrZ)); return *this; }
7313 LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() { return &self; }
7314 LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() { return &self; }
7315 const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator &() const { return &self; }
7316 const LDKCResult_PendingHTLCInfoInboundHTLCErrZ* operator ->() const { return &self; }
7318 class CResult_PendingHTLCInfoDecodeErrorZ {
7320 LDKCResult_PendingHTLCInfoDecodeErrorZ self;
7322 CResult_PendingHTLCInfoDecodeErrorZ(const CResult_PendingHTLCInfoDecodeErrorZ&) = delete;
7323 CResult_PendingHTLCInfoDecodeErrorZ(CResult_PendingHTLCInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); }
7324 CResult_PendingHTLCInfoDecodeErrorZ(LDKCResult_PendingHTLCInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); }
7325 operator LDKCResult_PendingHTLCInfoDecodeErrorZ() && { LDKCResult_PendingHTLCInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCInfoDecodeErrorZ)); return res; }
7326 ~CResult_PendingHTLCInfoDecodeErrorZ() { CResult_PendingHTLCInfoDecodeErrorZ_free(self); }
7327 CResult_PendingHTLCInfoDecodeErrorZ& operator=(CResult_PendingHTLCInfoDecodeErrorZ&& o) { CResult_PendingHTLCInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCInfoDecodeErrorZ)); return *this; }
7328 LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() { return &self; }
7329 LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() { return &self; }
7330 const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator &() const { return &self; }
7331 const LDKCResult_PendingHTLCInfoDecodeErrorZ* operator ->() const { return &self; }
7333 class COption_HTLCDestinationZ {
7335 LDKCOption_HTLCDestinationZ self;
7337 COption_HTLCDestinationZ(const COption_HTLCDestinationZ&) = delete;
7338 COption_HTLCDestinationZ(COption_HTLCDestinationZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCDestinationZ)); }
7339 COption_HTLCDestinationZ(LDKCOption_HTLCDestinationZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCDestinationZ)); }
7340 operator LDKCOption_HTLCDestinationZ() && { LDKCOption_HTLCDestinationZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCDestinationZ)); return res; }
7341 ~COption_HTLCDestinationZ() { COption_HTLCDestinationZ_free(self); }
7342 COption_HTLCDestinationZ& operator=(COption_HTLCDestinationZ&& o) { COption_HTLCDestinationZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCDestinationZ)); return *this; }
7343 LDKCOption_HTLCDestinationZ* operator &() { return &self; }
7344 LDKCOption_HTLCDestinationZ* operator ->() { return &self; }
7345 const LDKCOption_HTLCDestinationZ* operator &() const { return &self; }
7346 const LDKCOption_HTLCDestinationZ* operator ->() const { return &self; }
7348 class CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ {
7350 LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ self;
7352 CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(const CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&) = delete;
7353 CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
7354 CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); }
7355 operator LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() && { LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return res; }
7356 ~CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ() { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); }
7357 CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ& operator=(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ&& o) { CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ)); return *this; }
7358 LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() { return &self; }
7359 LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() { return &self; }
7360 const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator &() const { return &self; }
7361 const LDKCResult_C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZNoneZ* operator ->() const { return &self; }
7363 class CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ {
7365 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ self;
7367 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(const CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&) = delete;
7368 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
7369 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); }
7370 operator LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() && { LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ)); return res; }
7371 ~CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ() { CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(self); }
7372 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; }
7373 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() { return &self; }
7374 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() { return &self; }
7375 const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator &() const { return &self; }
7376 const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ* operator ->() const { return &self; }
7378 class CVec_RouteHopZ {
7380 LDKCVec_RouteHopZ self;
7382 CVec_RouteHopZ(const CVec_RouteHopZ&) = delete;
7383 CVec_RouteHopZ(CVec_RouteHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHopZ)); }
7384 CVec_RouteHopZ(LDKCVec_RouteHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHopZ)); }
7385 operator LDKCVec_RouteHopZ() && { LDKCVec_RouteHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHopZ)); return res; }
7386 ~CVec_RouteHopZ() { CVec_RouteHopZ_free(self); }
7387 CVec_RouteHopZ& operator=(CVec_RouteHopZ&& o) { CVec_RouteHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHopZ)); return *this; }
7388 LDKCVec_RouteHopZ* operator &() { return &self; }
7389 LDKCVec_RouteHopZ* operator ->() { return &self; }
7390 const LDKCVec_RouteHopZ* operator &() const { return &self; }
7391 const LDKCVec_RouteHopZ* operator ->() const { return &self; }
7393 class C2Tuple_PublicKeyCVec_SocketAddressZZ {
7395 LDKC2Tuple_PublicKeyCVec_SocketAddressZZ self;
7397 C2Tuple_PublicKeyCVec_SocketAddressZZ(const C2Tuple_PublicKeyCVec_SocketAddressZZ&) = delete;
7398 C2Tuple_PublicKeyCVec_SocketAddressZZ(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); }
7399 C2Tuple_PublicKeyCVec_SocketAddressZZ(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); }
7400 operator LDKC2Tuple_PublicKeyCVec_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCVec_SocketAddressZZ)); return res; }
7401 ~C2Tuple_PublicKeyCVec_SocketAddressZZ() { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); }
7402 C2Tuple_PublicKeyCVec_SocketAddressZZ& operator=(C2Tuple_PublicKeyCVec_SocketAddressZZ&& o) { C2Tuple_PublicKeyCVec_SocketAddressZZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyCVec_SocketAddressZZ)); return *this; }
7403 LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() { return &self; }
7404 LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() { return &self; }
7405 const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator &() const { return &self; }
7406 const LDKC2Tuple_PublicKeyCVec_SocketAddressZZ* operator ->() const { return &self; }
7408 class CResult_CVec_UtxoZNoneZ {
7410 LDKCResult_CVec_UtxoZNoneZ self;
7412 CResult_CVec_UtxoZNoneZ(const CResult_CVec_UtxoZNoneZ&) = delete;
7413 CResult_CVec_UtxoZNoneZ(CResult_CVec_UtxoZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_UtxoZNoneZ)); }
7414 CResult_CVec_UtxoZNoneZ(LDKCResult_CVec_UtxoZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); }
7415 operator LDKCResult_CVec_UtxoZNoneZ() && { LDKCResult_CVec_UtxoZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_UtxoZNoneZ)); return res; }
7416 ~CResult_CVec_UtxoZNoneZ() { CResult_CVec_UtxoZNoneZ_free(self); }
7417 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; }
7418 LDKCResult_CVec_UtxoZNoneZ* operator &() { return &self; }
7419 LDKCResult_CVec_UtxoZNoneZ* operator ->() { return &self; }
7420 const LDKCResult_CVec_UtxoZNoneZ* operator &() const { return &self; }
7421 const LDKCResult_CVec_UtxoZNoneZ* operator ->() const { return &self; }
7423 class CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ {
7425 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ self;
7427 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&) = delete;
7428 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
7429 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); }
7430 operator LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ)); return res; }
7431 ~CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(self); }
7432 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; }
7433 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() { return &self; }
7434 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() { return &self; }
7435 const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator &() const { return &self; }
7436 const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ* operator ->() const { return &self; }
7438 class CResult_CVec_u8ZIOErrorZ {
7440 LDKCResult_CVec_u8ZIOErrorZ self;
7442 CResult_CVec_u8ZIOErrorZ(const CResult_CVec_u8ZIOErrorZ&) = delete;
7443 CResult_CVec_u8ZIOErrorZ(CResult_CVec_u8ZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZIOErrorZ)); }
7444 CResult_CVec_u8ZIOErrorZ(LDKCResult_CVec_u8ZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); }
7445 operator LDKCResult_CVec_u8ZIOErrorZ() && { LDKCResult_CVec_u8ZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZIOErrorZ)); return res; }
7446 ~CResult_CVec_u8ZIOErrorZ() { CResult_CVec_u8ZIOErrorZ_free(self); }
7447 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; }
7448 LDKCResult_CVec_u8ZIOErrorZ* operator &() { return &self; }
7449 LDKCResult_CVec_u8ZIOErrorZ* operator ->() { return &self; }
7450 const LDKCResult_CVec_u8ZIOErrorZ* operator &() const { return &self; }
7451 const LDKCResult_CVec_u8ZIOErrorZ* operator ->() const { return &self; }
7453 class C3Tuple_OffersMessageDestinationBlindedPathZ {
7455 LDKC3Tuple_OffersMessageDestinationBlindedPathZ self;
7457 C3Tuple_OffersMessageDestinationBlindedPathZ(const C3Tuple_OffersMessageDestinationBlindedPathZ&) = delete;
7458 C3Tuple_OffersMessageDestinationBlindedPathZ(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); }
7459 C3Tuple_OffersMessageDestinationBlindedPathZ(LDKC3Tuple_OffersMessageDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); }
7460 operator LDKC3Tuple_OffersMessageDestinationBlindedPathZ() && { LDKC3Tuple_OffersMessageDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OffersMessageDestinationBlindedPathZ)); return res; }
7461 ~C3Tuple_OffersMessageDestinationBlindedPathZ() { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); }
7462 C3Tuple_OffersMessageDestinationBlindedPathZ& operator=(C3Tuple_OffersMessageDestinationBlindedPathZ&& o) { C3Tuple_OffersMessageDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OffersMessageDestinationBlindedPathZ)); return *this; }
7463 LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() { return &self; }
7464 LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() { return &self; }
7465 const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator &() const { return &self; }
7466 const LDKC3Tuple_OffersMessageDestinationBlindedPathZ* operator ->() const { return &self; }
7468 class CVec_ThirtyTwoBytesZ {
7470 LDKCVec_ThirtyTwoBytesZ self;
7472 CVec_ThirtyTwoBytesZ(const CVec_ThirtyTwoBytesZ&) = delete;
7473 CVec_ThirtyTwoBytesZ(CVec_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); }
7474 CVec_ThirtyTwoBytesZ(LDKCVec_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); }
7475 operator LDKCVec_ThirtyTwoBytesZ() && { LDKCVec_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCVec_ThirtyTwoBytesZ)); return res; }
7476 ~CVec_ThirtyTwoBytesZ() { CVec_ThirtyTwoBytesZ_free(self); }
7477 CVec_ThirtyTwoBytesZ& operator=(CVec_ThirtyTwoBytesZ&& o) { CVec_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ThirtyTwoBytesZ)); return *this; }
7478 LDKCVec_ThirtyTwoBytesZ* operator &() { return &self; }
7479 LDKCVec_ThirtyTwoBytesZ* operator ->() { return &self; }
7480 const LDKCVec_ThirtyTwoBytesZ* operator &() const { return &self; }
7481 const LDKCVec_ThirtyTwoBytesZ* operator ->() const { return &self; }
7483 class CResult_ChannelMonitorUpdateStatusNoneZ {
7485 LDKCResult_ChannelMonitorUpdateStatusNoneZ self;
7487 CResult_ChannelMonitorUpdateStatusNoneZ(const CResult_ChannelMonitorUpdateStatusNoneZ&) = delete;
7488 CResult_ChannelMonitorUpdateStatusNoneZ(CResult_ChannelMonitorUpdateStatusNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); }
7489 CResult_ChannelMonitorUpdateStatusNoneZ(LDKCResult_ChannelMonitorUpdateStatusNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); }
7490 operator LDKCResult_ChannelMonitorUpdateStatusNoneZ() && { LDKCResult_ChannelMonitorUpdateStatusNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ)); return res; }
7491 ~CResult_ChannelMonitorUpdateStatusNoneZ() { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); }
7492 CResult_ChannelMonitorUpdateStatusNoneZ& operator=(CResult_ChannelMonitorUpdateStatusNoneZ&& o) { CResult_ChannelMonitorUpdateStatusNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateStatusNoneZ)); return *this; }
7493 LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() { return &self; }
7494 LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() { return &self; }
7495 const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator &() const { return &self; }
7496 const LDKCResult_ChannelMonitorUpdateStatusNoneZ* operator ->() const { return &self; }
7498 class CResult_ClosingSignedDecodeErrorZ {
7500 LDKCResult_ClosingSignedDecodeErrorZ self;
7502 CResult_ClosingSignedDecodeErrorZ(const CResult_ClosingSignedDecodeErrorZ&) = delete;
7503 CResult_ClosingSignedDecodeErrorZ(CResult_ClosingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); }
7504 CResult_ClosingSignedDecodeErrorZ(LDKCResult_ClosingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); }
7505 operator LDKCResult_ClosingSignedDecodeErrorZ() && { LDKCResult_ClosingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClosingSignedDecodeErrorZ)); return res; }
7506 ~CResult_ClosingSignedDecodeErrorZ() { CResult_ClosingSignedDecodeErrorZ_free(self); }
7507 CResult_ClosingSignedDecodeErrorZ& operator=(CResult_ClosingSignedDecodeErrorZ&& o) { CResult_ClosingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClosingSignedDecodeErrorZ)); return *this; }
7508 LDKCResult_ClosingSignedDecodeErrorZ* operator &() { return &self; }
7509 LDKCResult_ClosingSignedDecodeErrorZ* operator ->() { return &self; }
7510 const LDKCResult_ClosingSignedDecodeErrorZ* operator &() const { return &self; }
7511 const LDKCResult_ClosingSignedDecodeErrorZ* operator ->() const { return &self; }
7513 class CVec_CResult_NoneAPIErrorZZ {
7515 LDKCVec_CResult_NoneAPIErrorZZ self;
7517 CVec_CResult_NoneAPIErrorZZ(const CVec_CResult_NoneAPIErrorZZ&) = delete;
7518 CVec_CResult_NoneAPIErrorZZ(CVec_CResult_NoneAPIErrorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CResult_NoneAPIErrorZZ)); }
7519 CVec_CResult_NoneAPIErrorZZ(LDKCVec_CResult_NoneAPIErrorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); }
7520 operator LDKCVec_CResult_NoneAPIErrorZZ() && { LDKCVec_CResult_NoneAPIErrorZZ res = self; memset(&self, 0, sizeof(LDKCVec_CResult_NoneAPIErrorZZ)); return res; }
7521 ~CVec_CResult_NoneAPIErrorZZ() { CVec_CResult_NoneAPIErrorZZ_free(self); }
7522 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; }
7523 LDKCVec_CResult_NoneAPIErrorZZ* operator &() { return &self; }
7524 LDKCVec_CResult_NoneAPIErrorZZ* operator ->() { return &self; }
7525 const LDKCVec_CResult_NoneAPIErrorZZ* operator &() const { return &self; }
7526 const LDKCVec_CResult_NoneAPIErrorZZ* operator ->() const { return &self; }
7528 class CResult_SchnorrSignatureNoneZ {
7530 LDKCResult_SchnorrSignatureNoneZ self;
7532 CResult_SchnorrSignatureNoneZ(const CResult_SchnorrSignatureNoneZ&) = delete;
7533 CResult_SchnorrSignatureNoneZ(CResult_SchnorrSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); }
7534 CResult_SchnorrSignatureNoneZ(LDKCResult_SchnorrSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); }
7535 operator LDKCResult_SchnorrSignatureNoneZ() && { LDKCResult_SchnorrSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_SchnorrSignatureNoneZ)); return res; }
7536 ~CResult_SchnorrSignatureNoneZ() { CResult_SchnorrSignatureNoneZ_free(self); }
7537 CResult_SchnorrSignatureNoneZ& operator=(CResult_SchnorrSignatureNoneZ&& o) { CResult_SchnorrSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SchnorrSignatureNoneZ)); return *this; }
7538 LDKCResult_SchnorrSignatureNoneZ* operator &() { return &self; }
7539 LDKCResult_SchnorrSignatureNoneZ* operator ->() { return &self; }
7540 const LDKCResult_SchnorrSignatureNoneZ* operator &() const { return &self; }
7541 const LDKCResult_SchnorrSignatureNoneZ* operator ->() const { return &self; }
7543 class CResult_CounterpartyCommitmentSecretsDecodeErrorZ {
7545 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ self;
7547 CResult_CounterpartyCommitmentSecretsDecodeErrorZ(const CResult_CounterpartyCommitmentSecretsDecodeErrorZ&) = delete;
7548 CResult_CounterpartyCommitmentSecretsDecodeErrorZ(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7549 CResult_CounterpartyCommitmentSecretsDecodeErrorZ(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); }
7550 operator LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ() && { LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return res; }
7551 ~CResult_CounterpartyCommitmentSecretsDecodeErrorZ() { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); }
7552 CResult_CounterpartyCommitmentSecretsDecodeErrorZ& operator=(CResult_CounterpartyCommitmentSecretsDecodeErrorZ&& o) { CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyCommitmentSecretsDecodeErrorZ)); return *this; }
7553 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() { return &self; }
7554 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() { return &self; }
7555 const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator &() const { return &self; }
7556 const LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* operator ->() const { return &self; }
7558 class CResult_HTLCDescriptorDecodeErrorZ {
7560 LDKCResult_HTLCDescriptorDecodeErrorZ self;
7562 CResult_HTLCDescriptorDecodeErrorZ(const CResult_HTLCDescriptorDecodeErrorZ&) = delete;
7563 CResult_HTLCDescriptorDecodeErrorZ(CResult_HTLCDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); }
7564 CResult_HTLCDescriptorDecodeErrorZ(LDKCResult_HTLCDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); }
7565 operator LDKCResult_HTLCDescriptorDecodeErrorZ() && { LDKCResult_HTLCDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ)); return res; }
7566 ~CResult_HTLCDescriptorDecodeErrorZ() { CResult_HTLCDescriptorDecodeErrorZ_free(self); }
7567 CResult_HTLCDescriptorDecodeErrorZ& operator=(CResult_HTLCDescriptorDecodeErrorZ&& o) { CResult_HTLCDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCDescriptorDecodeErrorZ)); return *this; }
7568 LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() { return &self; }
7569 LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() { return &self; }
7570 const LDKCResult_HTLCDescriptorDecodeErrorZ* operator &() const { return &self; }
7571 const LDKCResult_HTLCDescriptorDecodeErrorZ* operator ->() const { return &self; }
7573 class CVec_RecentPaymentDetailsZ {
7575 LDKCVec_RecentPaymentDetailsZ self;
7577 CVec_RecentPaymentDetailsZ(const CVec_RecentPaymentDetailsZ&) = delete;
7578 CVec_RecentPaymentDetailsZ(CVec_RecentPaymentDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); }
7579 CVec_RecentPaymentDetailsZ(LDKCVec_RecentPaymentDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); }
7580 operator LDKCVec_RecentPaymentDetailsZ() && { LDKCVec_RecentPaymentDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_RecentPaymentDetailsZ)); return res; }
7581 ~CVec_RecentPaymentDetailsZ() { CVec_RecentPaymentDetailsZ_free(self); }
7582 CVec_RecentPaymentDetailsZ& operator=(CVec_RecentPaymentDetailsZ&& o) { CVec_RecentPaymentDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RecentPaymentDetailsZ)); return *this; }
7583 LDKCVec_RecentPaymentDetailsZ* operator &() { return &self; }
7584 LDKCVec_RecentPaymentDetailsZ* operator ->() { return &self; }
7585 const LDKCVec_RecentPaymentDetailsZ* operator &() const { return &self; }
7586 const LDKCVec_RecentPaymentDetailsZ* operator ->() const { return &self; }
7588 class CVec_RouteHintHopZ {
7590 LDKCVec_RouteHintHopZ self;
7592 CVec_RouteHintHopZ(const CVec_RouteHintHopZ&) = delete;
7593 CVec_RouteHintHopZ(CVec_RouteHintHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintHopZ)); }
7594 CVec_RouteHintHopZ(LDKCVec_RouteHintHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintHopZ)); }
7595 operator LDKCVec_RouteHintHopZ() && { LDKCVec_RouteHintHopZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintHopZ)); return res; }
7596 ~CVec_RouteHintHopZ() { CVec_RouteHintHopZ_free(self); }
7597 CVec_RouteHintHopZ& operator=(CVec_RouteHintHopZ&& o) { CVec_RouteHintHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintHopZ)); return *this; }
7598 LDKCVec_RouteHintHopZ* operator &() { return &self; }
7599 LDKCVec_RouteHintHopZ* operator ->() { return &self; }
7600 const LDKCVec_RouteHintHopZ* operator &() const { return &self; }
7601 const LDKCVec_RouteHintHopZ* operator ->() const { return &self; }
7603 class CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ {
7605 LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ self;
7607 CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(const CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&) = delete;
7608 CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
7609 CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); }
7610 operator LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return res; }
7611 ~CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ() { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); }
7612 CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ& operator=(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ&& o) { CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ)); return *this; }
7613 LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() { return &self; }
7614 LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() { return &self; }
7615 const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator &() const { return &self; }
7616 const LDKCVec_C3Tuple_OffersMessageDestinationBlindedPathZZ* operator ->() const { return &self; }
7618 class CResult_UntrustedStringDecodeErrorZ {
7620 LDKCResult_UntrustedStringDecodeErrorZ self;
7622 CResult_UntrustedStringDecodeErrorZ(const CResult_UntrustedStringDecodeErrorZ&) = delete;
7623 CResult_UntrustedStringDecodeErrorZ(CResult_UntrustedStringDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); }
7624 CResult_UntrustedStringDecodeErrorZ(LDKCResult_UntrustedStringDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); }
7625 operator LDKCResult_UntrustedStringDecodeErrorZ() && { LDKCResult_UntrustedStringDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UntrustedStringDecodeErrorZ)); return res; }
7626 ~CResult_UntrustedStringDecodeErrorZ() { CResult_UntrustedStringDecodeErrorZ_free(self); }
7627 CResult_UntrustedStringDecodeErrorZ& operator=(CResult_UntrustedStringDecodeErrorZ&& o) { CResult_UntrustedStringDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UntrustedStringDecodeErrorZ)); return *this; }
7628 LDKCResult_UntrustedStringDecodeErrorZ* operator &() { return &self; }
7629 LDKCResult_UntrustedStringDecodeErrorZ* operator ->() { return &self; }
7630 const LDKCResult_UntrustedStringDecodeErrorZ* operator &() const { return &self; }
7631 const LDKCResult_UntrustedStringDecodeErrorZ* operator ->() const { return &self; }
7633 class CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ {
7635 LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ self;
7637 CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(const CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&) = delete;
7638 CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
7639 CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); }
7640 operator LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() && { LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return res; }
7641 ~CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ() { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); }
7642 CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ& operator=(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ&& o) { CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ)); return *this; }
7643 LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() { return &self; }
7644 LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() { return &self; }
7645 const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator &() const { return &self; }
7646 const LDKCVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ* operator ->() const { return &self; }
7652 CVec_U5Z(const CVec_U5Z&) = delete;
7653 CVec_U5Z(CVec_U5Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_U5Z)); }
7654 CVec_U5Z(LDKCVec_U5Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_U5Z)); }
7655 operator LDKCVec_U5Z() && { LDKCVec_U5Z res = self; memset(&self, 0, sizeof(LDKCVec_U5Z)); return res; }
7656 ~CVec_U5Z() { CVec_U5Z_free(self); }
7657 CVec_U5Z& operator=(CVec_U5Z&& o) { CVec_U5Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_U5Z)); return *this; }
7658 LDKCVec_U5Z* operator &() { return &self; }
7659 LDKCVec_U5Z* operator ->() { return &self; }
7660 const LDKCVec_U5Z* operator &() const { return &self; }
7661 const LDKCVec_U5Z* operator ->() const { return &self; }
7663 class CResult_PaymentParametersDecodeErrorZ {
7665 LDKCResult_PaymentParametersDecodeErrorZ self;
7667 CResult_PaymentParametersDecodeErrorZ(const CResult_PaymentParametersDecodeErrorZ&) = delete;
7668 CResult_PaymentParametersDecodeErrorZ(CResult_PaymentParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); }
7669 CResult_PaymentParametersDecodeErrorZ(LDKCResult_PaymentParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); }
7670 operator LDKCResult_PaymentParametersDecodeErrorZ() && { LDKCResult_PaymentParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentParametersDecodeErrorZ)); return res; }
7671 ~CResult_PaymentParametersDecodeErrorZ() { CResult_PaymentParametersDecodeErrorZ_free(self); }
7672 CResult_PaymentParametersDecodeErrorZ& operator=(CResult_PaymentParametersDecodeErrorZ&& o) { CResult_PaymentParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentParametersDecodeErrorZ)); return *this; }
7673 LDKCResult_PaymentParametersDecodeErrorZ* operator &() { return &self; }
7674 LDKCResult_PaymentParametersDecodeErrorZ* operator ->() { return &self; }
7675 const LDKCResult_PaymentParametersDecodeErrorZ* operator &() const { return &self; }
7676 const LDKCResult_PaymentParametersDecodeErrorZ* operator ->() const { return &self; }
7678 class C2Tuple_ThirtyTwoBytesChannelMonitorZ {
7680 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ self;
7682 C2Tuple_ThirtyTwoBytesChannelMonitorZ(const C2Tuple_ThirtyTwoBytesChannelMonitorZ&) = delete;
7683 C2Tuple_ThirtyTwoBytesChannelMonitorZ(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7684 C2Tuple_ThirtyTwoBytesChannelMonitorZ(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); }
7685 operator LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ() && { LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ)); return res; }
7686 ~C2Tuple_ThirtyTwoBytesChannelMonitorZ() { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); }
7687 C2Tuple_ThirtyTwoBytesChannelMonitorZ& operator=(C2Tuple_ThirtyTwoBytesChannelMonitorZ&& o) { C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelMonitorZ)); return *this; }
7688 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() { return &self; }
7689 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() { return &self; }
7690 const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator &() const { return &self; }
7691 const LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* operator ->() const { return &self; }
7693 class COption_U128Z {
7695 LDKCOption_U128Z self;
7697 COption_U128Z(const COption_U128Z&) = delete;
7698 COption_U128Z(COption_U128Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_U128Z)); }
7699 COption_U128Z(LDKCOption_U128Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_U128Z)); }
7700 operator LDKCOption_U128Z() && { LDKCOption_U128Z res = self; memset(&self, 0, sizeof(LDKCOption_U128Z)); return res; }
7701 ~COption_U128Z() { COption_U128Z_free(self); }
7702 COption_U128Z& operator=(COption_U128Z&& o) { COption_U128Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_U128Z)); return *this; }
7703 LDKCOption_U128Z* operator &() { return &self; }
7704 LDKCOption_U128Z* operator ->() { return &self; }
7705 const LDKCOption_U128Z* operator &() const { return &self; }
7706 const LDKCOption_U128Z* operator ->() const { return &self; }
7708 class CResult_DelayedPaymentBasepointDecodeErrorZ {
7710 LDKCResult_DelayedPaymentBasepointDecodeErrorZ self;
7712 CResult_DelayedPaymentBasepointDecodeErrorZ(const CResult_DelayedPaymentBasepointDecodeErrorZ&) = delete;
7713 CResult_DelayedPaymentBasepointDecodeErrorZ(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); }
7714 CResult_DelayedPaymentBasepointDecodeErrorZ(LDKCResult_DelayedPaymentBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); }
7715 operator LDKCResult_DelayedPaymentBasepointDecodeErrorZ() && { LDKCResult_DelayedPaymentBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentBasepointDecodeErrorZ)); return res; }
7716 ~CResult_DelayedPaymentBasepointDecodeErrorZ() { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); }
7717 CResult_DelayedPaymentBasepointDecodeErrorZ& operator=(CResult_DelayedPaymentBasepointDecodeErrorZ&& o) { CResult_DelayedPaymentBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentBasepointDecodeErrorZ)); return *this; }
7718 LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() { return &self; }
7719 LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() { return &self; }
7720 const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator &() const { return &self; }
7721 const LDKCResult_DelayedPaymentBasepointDecodeErrorZ* operator ->() const { return &self; }
7723 class C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ {
7725 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ self;
7727 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(const C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&) = delete;
7728 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7729 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); }
7730 operator LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() && { LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return res; }
7731 ~C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ() { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); }
7732 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ& operator=(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ&& o) { C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ)); return *this; }
7733 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() { return &self; }
7734 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() { return &self; }
7735 const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator &() const { return &self; }
7736 const LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* operator ->() const { return &self; }
7738 class CResult_TxAckRbfDecodeErrorZ {
7740 LDKCResult_TxAckRbfDecodeErrorZ self;
7742 CResult_TxAckRbfDecodeErrorZ(const CResult_TxAckRbfDecodeErrorZ&) = delete;
7743 CResult_TxAckRbfDecodeErrorZ(CResult_TxAckRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); }
7744 CResult_TxAckRbfDecodeErrorZ(LDKCResult_TxAckRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); }
7745 operator LDKCResult_TxAckRbfDecodeErrorZ() && { LDKCResult_TxAckRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAckRbfDecodeErrorZ)); return res; }
7746 ~CResult_TxAckRbfDecodeErrorZ() { CResult_TxAckRbfDecodeErrorZ_free(self); }
7747 CResult_TxAckRbfDecodeErrorZ& operator=(CResult_TxAckRbfDecodeErrorZ&& o) { CResult_TxAckRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAckRbfDecodeErrorZ)); return *this; }
7748 LDKCResult_TxAckRbfDecodeErrorZ* operator &() { return &self; }
7749 LDKCResult_TxAckRbfDecodeErrorZ* operator ->() { return &self; }
7750 const LDKCResult_TxAckRbfDecodeErrorZ* operator &() const { return &self; }
7751 const LDKCResult_TxAckRbfDecodeErrorZ* operator ->() const { return &self; }
7753 class CResult_Bolt11InvoiceBolt11SemanticErrorZ {
7755 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ self;
7757 CResult_Bolt11InvoiceBolt11SemanticErrorZ(const CResult_Bolt11InvoiceBolt11SemanticErrorZ&) = delete;
7758 CResult_Bolt11InvoiceBolt11SemanticErrorZ(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7759 CResult_Bolt11InvoiceBolt11SemanticErrorZ(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); }
7760 operator LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ() && { LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ)); return res; }
7761 ~CResult_Bolt11InvoiceBolt11SemanticErrorZ() { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); }
7762 CResult_Bolt11InvoiceBolt11SemanticErrorZ& operator=(CResult_Bolt11InvoiceBolt11SemanticErrorZ&& o) { CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceBolt11SemanticErrorZ)); return *this; }
7763 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() { return &self; }
7764 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() { return &self; }
7765 const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator &() const { return &self; }
7766 const LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* operator ->() const { return &self; }
7768 class COption_UtxoLookupZ {
7770 LDKCOption_UtxoLookupZ self;
7772 COption_UtxoLookupZ(const COption_UtxoLookupZ&) = delete;
7773 COption_UtxoLookupZ(COption_UtxoLookupZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_UtxoLookupZ)); }
7774 COption_UtxoLookupZ(LDKCOption_UtxoLookupZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_UtxoLookupZ)); }
7775 operator LDKCOption_UtxoLookupZ() && { LDKCOption_UtxoLookupZ res = self; memset(&self, 0, sizeof(LDKCOption_UtxoLookupZ)); return res; }
7776 ~COption_UtxoLookupZ() { COption_UtxoLookupZ_free(self); }
7777 COption_UtxoLookupZ& operator=(COption_UtxoLookupZ&& o) { COption_UtxoLookupZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_UtxoLookupZ)); return *this; }
7778 LDKCOption_UtxoLookupZ* operator &() { return &self; }
7779 LDKCOption_UtxoLookupZ* operator ->() { return &self; }
7780 const LDKCOption_UtxoLookupZ* operator &() const { return &self; }
7781 const LDKCOption_UtxoLookupZ* operator ->() const { return &self; }
7783 class CResult_PongDecodeErrorZ {
7785 LDKCResult_PongDecodeErrorZ self;
7787 CResult_PongDecodeErrorZ(const CResult_PongDecodeErrorZ&) = delete;
7788 CResult_PongDecodeErrorZ(CResult_PongDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); }
7789 CResult_PongDecodeErrorZ(LDKCResult_PongDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); }
7790 operator LDKCResult_PongDecodeErrorZ() && { LDKCResult_PongDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PongDecodeErrorZ)); return res; }
7791 ~CResult_PongDecodeErrorZ() { CResult_PongDecodeErrorZ_free(self); }
7792 CResult_PongDecodeErrorZ& operator=(CResult_PongDecodeErrorZ&& o) { CResult_PongDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PongDecodeErrorZ)); return *this; }
7793 LDKCResult_PongDecodeErrorZ* operator &() { return &self; }
7794 LDKCResult_PongDecodeErrorZ* operator ->() { return &self; }
7795 const LDKCResult_PongDecodeErrorZ* operator &() const { return &self; }
7796 const LDKCResult_PongDecodeErrorZ* operator ->() const { return &self; }
7798 class CResult_UnsignedChannelAnnouncementDecodeErrorZ {
7800 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ self;
7802 CResult_UnsignedChannelAnnouncementDecodeErrorZ(const CResult_UnsignedChannelAnnouncementDecodeErrorZ&) = delete;
7803 CResult_UnsignedChannelAnnouncementDecodeErrorZ(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7804 CResult_UnsignedChannelAnnouncementDecodeErrorZ(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); }
7805 operator LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ)); return res; }
7806 ~CResult_UnsignedChannelAnnouncementDecodeErrorZ() { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); }
7807 CResult_UnsignedChannelAnnouncementDecodeErrorZ& operator=(CResult_UnsignedChannelAnnouncementDecodeErrorZ&& o) { CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelAnnouncementDecodeErrorZ)); return *this; }
7808 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
7809 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
7810 const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
7811 const LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
7813 class C2Tuple_OutPointCVec_MonitorUpdateIdZZ {
7815 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ self;
7817 C2Tuple_OutPointCVec_MonitorUpdateIdZZ(const C2Tuple_OutPointCVec_MonitorUpdateIdZZ&) = delete;
7818 C2Tuple_OutPointCVec_MonitorUpdateIdZZ(C2Tuple_OutPointCVec_MonitorUpdateIdZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7819 C2Tuple_OutPointCVec_MonitorUpdateIdZZ(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); }
7820 operator LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ() && { LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ)); return res; }
7821 ~C2Tuple_OutPointCVec_MonitorUpdateIdZZ() { C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(self); }
7822 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; }
7823 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() { return &self; }
7824 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() { return &self; }
7825 const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator &() const { return &self; }
7826 const LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* operator ->() const { return &self; }
7828 class CResult_CVec_u8ZNoneZ {
7830 LDKCResult_CVec_u8ZNoneZ self;
7832 CResult_CVec_u8ZNoneZ(const CResult_CVec_u8ZNoneZ&) = delete;
7833 CResult_CVec_u8ZNoneZ(CResult_CVec_u8ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_u8ZNoneZ)); }
7834 CResult_CVec_u8ZNoneZ(LDKCResult_CVec_u8ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); }
7835 operator LDKCResult_CVec_u8ZNoneZ() && { LDKCResult_CVec_u8ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_u8ZNoneZ)); return res; }
7836 ~CResult_CVec_u8ZNoneZ() { CResult_CVec_u8ZNoneZ_free(self); }
7837 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; }
7838 LDKCResult_CVec_u8ZNoneZ* operator &() { return &self; }
7839 LDKCResult_CVec_u8ZNoneZ* operator ->() { return &self; }
7840 const LDKCResult_CVec_u8ZNoneZ* operator &() const { return &self; }
7841 const LDKCResult_CVec_u8ZNoneZ* operator ->() const { return &self; }
7843 class C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ {
7845 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ self;
7847 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(const C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&) = delete;
7848 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7849 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); }
7850 operator LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() && { LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ)); return res; }
7851 ~C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ() { C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(self); }
7852 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; }
7853 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() { return &self; }
7854 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() { return &self; }
7855 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator &() const { return &self; }
7856 const LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* operator ->() const { return &self; }
7858 class CResult_ChannelTransactionParametersDecodeErrorZ {
7860 LDKCResult_ChannelTransactionParametersDecodeErrorZ self;
7862 CResult_ChannelTransactionParametersDecodeErrorZ(const CResult_ChannelTransactionParametersDecodeErrorZ&) = delete;
7863 CResult_ChannelTransactionParametersDecodeErrorZ(CResult_ChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); }
7864 CResult_ChannelTransactionParametersDecodeErrorZ(LDKCResult_ChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); }
7865 operator LDKCResult_ChannelTransactionParametersDecodeErrorZ() && { LDKCResult_ChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ)); return res; }
7866 ~CResult_ChannelTransactionParametersDecodeErrorZ() { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); }
7867 CResult_ChannelTransactionParametersDecodeErrorZ& operator=(CResult_ChannelTransactionParametersDecodeErrorZ&& o) { CResult_ChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTransactionParametersDecodeErrorZ)); return *this; }
7868 LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
7869 LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
7870 const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
7871 const LDKCResult_ChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
7873 class CResult_WriteableEcdsaChannelSignerDecodeErrorZ {
7875 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ self;
7877 CResult_WriteableEcdsaChannelSignerDecodeErrorZ(const CResult_WriteableEcdsaChannelSignerDecodeErrorZ&) = delete;
7878 CResult_WriteableEcdsaChannelSignerDecodeErrorZ(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7879 CResult_WriteableEcdsaChannelSignerDecodeErrorZ(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); }
7880 operator LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ() && { LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return res; }
7881 ~CResult_WriteableEcdsaChannelSignerDecodeErrorZ() { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); }
7882 CResult_WriteableEcdsaChannelSignerDecodeErrorZ& operator=(CResult_WriteableEcdsaChannelSignerDecodeErrorZ&& o) { CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WriteableEcdsaChannelSignerDecodeErrorZ)); return *this; }
7883 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() { return &self; }
7884 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() { return &self; }
7885 const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator &() const { return &self; }
7886 const LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* operator ->() const { return &self; }
7888 class CResult_DelayedPaymentOutputDescriptorDecodeErrorZ {
7890 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ self;
7892 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(const CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&) = delete;
7893 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7894 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); }
7895 operator LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ() && { LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return res; }
7896 ~CResult_DelayedPaymentOutputDescriptorDecodeErrorZ() { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); }
7897 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ& operator=(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ&& o) { CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentOutputDescriptorDecodeErrorZ)); return *this; }
7898 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() { return &self; }
7899 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
7900 const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
7901 const LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
7903 class CResult_InFlightHtlcsDecodeErrorZ {
7905 LDKCResult_InFlightHtlcsDecodeErrorZ self;
7907 CResult_InFlightHtlcsDecodeErrorZ(const CResult_InFlightHtlcsDecodeErrorZ&) = delete;
7908 CResult_InFlightHtlcsDecodeErrorZ(CResult_InFlightHtlcsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); }
7909 CResult_InFlightHtlcsDecodeErrorZ(LDKCResult_InFlightHtlcsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); }
7910 operator LDKCResult_InFlightHtlcsDecodeErrorZ() && { LDKCResult_InFlightHtlcsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ)); return res; }
7911 ~CResult_InFlightHtlcsDecodeErrorZ() { CResult_InFlightHtlcsDecodeErrorZ_free(self); }
7912 CResult_InFlightHtlcsDecodeErrorZ& operator=(CResult_InFlightHtlcsDecodeErrorZ&& o) { CResult_InFlightHtlcsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InFlightHtlcsDecodeErrorZ)); return *this; }
7913 LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() { return &self; }
7914 LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() { return &self; }
7915 const LDKCResult_InFlightHtlcsDecodeErrorZ* operator &() const { return &self; }
7916 const LDKCResult_InFlightHtlcsDecodeErrorZ* operator ->() const { return &self; }
7918 class CResult_COption_HTLCDestinationZDecodeErrorZ {
7920 LDKCResult_COption_HTLCDestinationZDecodeErrorZ self;
7922 CResult_COption_HTLCDestinationZDecodeErrorZ(const CResult_COption_HTLCDestinationZDecodeErrorZ&) = delete;
7923 CResult_COption_HTLCDestinationZDecodeErrorZ(CResult_COption_HTLCDestinationZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_HTLCDestinationZDecodeErrorZ)); }
7924 CResult_COption_HTLCDestinationZDecodeErrorZ(LDKCResult_COption_HTLCDestinationZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); }
7925 operator LDKCResult_COption_HTLCDestinationZDecodeErrorZ() && { LDKCResult_COption_HTLCDestinationZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ)); return res; }
7926 ~CResult_COption_HTLCDestinationZDecodeErrorZ() { CResult_COption_HTLCDestinationZDecodeErrorZ_free(self); }
7927 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; }
7928 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() { return &self; }
7929 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() { return &self; }
7930 const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator &() const { return &self; }
7931 const LDKCResult_COption_HTLCDestinationZDecodeErrorZ* operator ->() const { return &self; }
7933 class CResult_ThirtyTwoBytesNoneZ {
7935 LDKCResult_ThirtyTwoBytesNoneZ self;
7937 CResult_ThirtyTwoBytesNoneZ(const CResult_ThirtyTwoBytesNoneZ&) = delete;
7938 CResult_ThirtyTwoBytesNoneZ(CResult_ThirtyTwoBytesNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); }
7939 CResult_ThirtyTwoBytesNoneZ(LDKCResult_ThirtyTwoBytesNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); }
7940 operator LDKCResult_ThirtyTwoBytesNoneZ() && { LDKCResult_ThirtyTwoBytesNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesNoneZ)); return res; }
7941 ~CResult_ThirtyTwoBytesNoneZ() { CResult_ThirtyTwoBytesNoneZ_free(self); }
7942 CResult_ThirtyTwoBytesNoneZ& operator=(CResult_ThirtyTwoBytesNoneZ&& o) { CResult_ThirtyTwoBytesNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesNoneZ)); return *this; }
7943 LDKCResult_ThirtyTwoBytesNoneZ* operator &() { return &self; }
7944 LDKCResult_ThirtyTwoBytesNoneZ* operator ->() { return &self; }
7945 const LDKCResult_ThirtyTwoBytesNoneZ* operator &() const { return &self; }
7946 const LDKCResult_ThirtyTwoBytesNoneZ* operator ->() const { return &self; }
7948 class C3Tuple_OnionMessageContentsDestinationBlindedPathZ {
7950 LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ self;
7952 C3Tuple_OnionMessageContentsDestinationBlindedPathZ(const C3Tuple_OnionMessageContentsDestinationBlindedPathZ&) = delete;
7953 C3Tuple_OnionMessageContentsDestinationBlindedPathZ(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
7954 C3Tuple_OnionMessageContentsDestinationBlindedPathZ(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); }
7955 operator LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ() && { LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return res; }
7956 ~C3Tuple_OnionMessageContentsDestinationBlindedPathZ() { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); }
7957 C3Tuple_OnionMessageContentsDestinationBlindedPathZ& operator=(C3Tuple_OnionMessageContentsDestinationBlindedPathZ&& o) { C3Tuple_OnionMessageContentsDestinationBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_OnionMessageContentsDestinationBlindedPathZ)); return *this; }
7958 LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() { return &self; }
7959 LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() { return &self; }
7960 const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator &() const { return &self; }
7961 const LDKC3Tuple_OnionMessageContentsDestinationBlindedPathZ* operator ->() const { return &self; }
7963 class C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ {
7965 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ self;
7967 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(const C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&) = delete;
7968 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7969 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); }
7970 operator LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() && { LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ)); return res; }
7971 ~C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ() { C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(self); }
7972 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; }
7973 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() { return &self; }
7974 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() { return &self; }
7975 const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator &() const { return &self; }
7976 const LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* operator ->() const { return &self; }
7978 class CResult_SendSuccessSendErrorZ {
7980 LDKCResult_SendSuccessSendErrorZ self;
7982 CResult_SendSuccessSendErrorZ(const CResult_SendSuccessSendErrorZ&) = delete;
7983 CResult_SendSuccessSendErrorZ(CResult_SendSuccessSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); }
7984 CResult_SendSuccessSendErrorZ(LDKCResult_SendSuccessSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); }
7985 operator LDKCResult_SendSuccessSendErrorZ() && { LDKCResult_SendSuccessSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SendSuccessSendErrorZ)); return res; }
7986 ~CResult_SendSuccessSendErrorZ() { CResult_SendSuccessSendErrorZ_free(self); }
7987 CResult_SendSuccessSendErrorZ& operator=(CResult_SendSuccessSendErrorZ&& o) { CResult_SendSuccessSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SendSuccessSendErrorZ)); return *this; }
7988 LDKCResult_SendSuccessSendErrorZ* operator &() { return &self; }
7989 LDKCResult_SendSuccessSendErrorZ* operator ->() { return &self; }
7990 const LDKCResult_SendSuccessSendErrorZ* operator &() const { return &self; }
7991 const LDKCResult_SendSuccessSendErrorZ* operator ->() const { return &self; }
7993 class CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ {
7995 LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ self;
7997 CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(const CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&) = delete;
7998 CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
7999 CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); }
8000 operator LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() && { LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return res; }
8001 ~CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ() { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); }
8002 CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ& operator=(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ&& o) { CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ)); return *this; }
8003 LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() { return &self; }
8004 LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() { return &self; }
8005 const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator &() const { return &self; }
8006 const LDKCVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ* operator ->() const { return &self; }
8008 class C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ {
8010 LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ self;
8012 C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(const C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&) = delete;
8013 C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
8014 C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); }
8015 operator LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() && { LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return res; }
8016 ~C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ() { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); }
8017 C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ& operator=(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ&& o) { C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ)); return *this; }
8018 LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() { return &self; }
8019 LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() { return &self; }
8020 const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator &() const { return &self; }
8021 const LDKC3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZ* operator ->() const { return &self; }
8023 class CResult_BlindedHopDecodeErrorZ {
8025 LDKCResult_BlindedHopDecodeErrorZ self;
8027 CResult_BlindedHopDecodeErrorZ(const CResult_BlindedHopDecodeErrorZ&) = delete;
8028 CResult_BlindedHopDecodeErrorZ(CResult_BlindedHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); }
8029 CResult_BlindedHopDecodeErrorZ(LDKCResult_BlindedHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); }
8030 operator LDKCResult_BlindedHopDecodeErrorZ() && { LDKCResult_BlindedHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopDecodeErrorZ)); return res; }
8031 ~CResult_BlindedHopDecodeErrorZ() { CResult_BlindedHopDecodeErrorZ_free(self); }
8032 CResult_BlindedHopDecodeErrorZ& operator=(CResult_BlindedHopDecodeErrorZ&& o) { CResult_BlindedHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopDecodeErrorZ)); return *this; }
8033 LDKCResult_BlindedHopDecodeErrorZ* operator &() { return &self; }
8034 LDKCResult_BlindedHopDecodeErrorZ* operator ->() { return &self; }
8035 const LDKCResult_BlindedHopDecodeErrorZ* operator &() const { return &self; }
8036 const LDKCResult_BlindedHopDecodeErrorZ* operator ->() const { return &self; }
8038 class CResult_NoneLightningErrorZ {
8040 LDKCResult_NoneLightningErrorZ self;
8042 CResult_NoneLightningErrorZ(const CResult_NoneLightningErrorZ&) = delete;
8043 CResult_NoneLightningErrorZ(CResult_NoneLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); }
8044 CResult_NoneLightningErrorZ(LDKCResult_NoneLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); }
8045 operator LDKCResult_NoneLightningErrorZ() && { LDKCResult_NoneLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneLightningErrorZ)); return res; }
8046 ~CResult_NoneLightningErrorZ() { CResult_NoneLightningErrorZ_free(self); }
8047 CResult_NoneLightningErrorZ& operator=(CResult_NoneLightningErrorZ&& o) { CResult_NoneLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneLightningErrorZ)); return *this; }
8048 LDKCResult_NoneLightningErrorZ* operator &() { return &self; }
8049 LDKCResult_NoneLightningErrorZ* operator ->() { return &self; }
8050 const LDKCResult_NoneLightningErrorZ* operator &() const { return &self; }
8051 const LDKCResult_NoneLightningErrorZ* operator ->() const { return &self; }
8053 class CResult_FixedPenaltyScorerDecodeErrorZ {
8055 LDKCResult_FixedPenaltyScorerDecodeErrorZ self;
8057 CResult_FixedPenaltyScorerDecodeErrorZ(const CResult_FixedPenaltyScorerDecodeErrorZ&) = delete;
8058 CResult_FixedPenaltyScorerDecodeErrorZ(CResult_FixedPenaltyScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); }
8059 CResult_FixedPenaltyScorerDecodeErrorZ(LDKCResult_FixedPenaltyScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); }
8060 operator LDKCResult_FixedPenaltyScorerDecodeErrorZ() && { LDKCResult_FixedPenaltyScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ)); return res; }
8061 ~CResult_FixedPenaltyScorerDecodeErrorZ() { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); }
8062 CResult_FixedPenaltyScorerDecodeErrorZ& operator=(CResult_FixedPenaltyScorerDecodeErrorZ&& o) { CResult_FixedPenaltyScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FixedPenaltyScorerDecodeErrorZ)); return *this; }
8063 LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() { return &self; }
8064 LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() { return &self; }
8065 const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator &() const { return &self; }
8066 const LDKCResult_FixedPenaltyScorerDecodeErrorZ* operator ->() const { return &self; }
8068 class CVec_BlindedPathZ {
8070 LDKCVec_BlindedPathZ self;
8072 CVec_BlindedPathZ(const CVec_BlindedPathZ&) = delete;
8073 CVec_BlindedPathZ(CVec_BlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedPathZ)); }
8074 CVec_BlindedPathZ(LDKCVec_BlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedPathZ)); }
8075 operator LDKCVec_BlindedPathZ() && { LDKCVec_BlindedPathZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedPathZ)); return res; }
8076 ~CVec_BlindedPathZ() { CVec_BlindedPathZ_free(self); }
8077 CVec_BlindedPathZ& operator=(CVec_BlindedPathZ&& o) { CVec_BlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedPathZ)); return *this; }
8078 LDKCVec_BlindedPathZ* operator &() { return &self; }
8079 LDKCVec_BlindedPathZ* operator ->() { return &self; }
8080 const LDKCVec_BlindedPathZ* operator &() const { return &self; }
8081 const LDKCVec_BlindedPathZ* operator ->() const { return &self; }
8083 class CResult_NonePeerHandleErrorZ {
8085 LDKCResult_NonePeerHandleErrorZ self;
8087 CResult_NonePeerHandleErrorZ(const CResult_NonePeerHandleErrorZ&) = delete;
8088 CResult_NonePeerHandleErrorZ(CResult_NonePeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); }
8089 CResult_NonePeerHandleErrorZ(LDKCResult_NonePeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); }
8090 operator LDKCResult_NonePeerHandleErrorZ() && { LDKCResult_NonePeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePeerHandleErrorZ)); return res; }
8091 ~CResult_NonePeerHandleErrorZ() { CResult_NonePeerHandleErrorZ_free(self); }
8092 CResult_NonePeerHandleErrorZ& operator=(CResult_NonePeerHandleErrorZ&& o) { CResult_NonePeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePeerHandleErrorZ)); return *this; }
8093 LDKCResult_NonePeerHandleErrorZ* operator &() { return &self; }
8094 LDKCResult_NonePeerHandleErrorZ* operator ->() { return &self; }
8095 const LDKCResult_NonePeerHandleErrorZ* operator &() const { return &self; }
8096 const LDKCResult_NonePeerHandleErrorZ* operator ->() const { return &self; }
8098 class CResult_FinalOnionHopDataDecodeErrorZ {
8100 LDKCResult_FinalOnionHopDataDecodeErrorZ self;
8102 CResult_FinalOnionHopDataDecodeErrorZ(const CResult_FinalOnionHopDataDecodeErrorZ&) = delete;
8103 CResult_FinalOnionHopDataDecodeErrorZ(CResult_FinalOnionHopDataDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); }
8104 CResult_FinalOnionHopDataDecodeErrorZ(LDKCResult_FinalOnionHopDataDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); }
8105 operator LDKCResult_FinalOnionHopDataDecodeErrorZ() && { LDKCResult_FinalOnionHopDataDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FinalOnionHopDataDecodeErrorZ)); return res; }
8106 ~CResult_FinalOnionHopDataDecodeErrorZ() { CResult_FinalOnionHopDataDecodeErrorZ_free(self); }
8107 CResult_FinalOnionHopDataDecodeErrorZ& operator=(CResult_FinalOnionHopDataDecodeErrorZ&& o) { CResult_FinalOnionHopDataDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FinalOnionHopDataDecodeErrorZ)); return *this; }
8108 LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() { return &self; }
8109 LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() { return &self; }
8110 const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator &() const { return &self; }
8111 const LDKCResult_FinalOnionHopDataDecodeErrorZ* operator ->() const { return &self; }
8113 class CResult_TrustedCommitmentTransactionNoneZ {
8115 LDKCResult_TrustedCommitmentTransactionNoneZ self;
8117 CResult_TrustedCommitmentTransactionNoneZ(const CResult_TrustedCommitmentTransactionNoneZ&) = delete;
8118 CResult_TrustedCommitmentTransactionNoneZ(CResult_TrustedCommitmentTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); }
8119 CResult_TrustedCommitmentTransactionNoneZ(LDKCResult_TrustedCommitmentTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); }
8120 operator LDKCResult_TrustedCommitmentTransactionNoneZ() && { LDKCResult_TrustedCommitmentTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ)); return res; }
8121 ~CResult_TrustedCommitmentTransactionNoneZ() { CResult_TrustedCommitmentTransactionNoneZ_free(self); }
8122 CResult_TrustedCommitmentTransactionNoneZ& operator=(CResult_TrustedCommitmentTransactionNoneZ&& o) { CResult_TrustedCommitmentTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedCommitmentTransactionNoneZ)); return *this; }
8123 LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() { return &self; }
8124 LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() { return &self; }
8125 const LDKCResult_TrustedCommitmentTransactionNoneZ* operator &() const { return &self; }
8126 const LDKCResult_TrustedCommitmentTransactionNoneZ* operator ->() const { return &self; }
8128 class CResult_COption_EventZDecodeErrorZ {
8130 LDKCResult_COption_EventZDecodeErrorZ self;
8132 CResult_COption_EventZDecodeErrorZ(const CResult_COption_EventZDecodeErrorZ&) = delete;
8133 CResult_COption_EventZDecodeErrorZ(CResult_COption_EventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_EventZDecodeErrorZ)); }
8134 CResult_COption_EventZDecodeErrorZ(LDKCResult_COption_EventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); }
8135 operator LDKCResult_COption_EventZDecodeErrorZ() && { LDKCResult_COption_EventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_EventZDecodeErrorZ)); return res; }
8136 ~CResult_COption_EventZDecodeErrorZ() { CResult_COption_EventZDecodeErrorZ_free(self); }
8137 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; }
8138 LDKCResult_COption_EventZDecodeErrorZ* operator &() { return &self; }
8139 LDKCResult_COption_EventZDecodeErrorZ* operator ->() { return &self; }
8140 const LDKCResult_COption_EventZDecodeErrorZ* operator &() const { return &self; }
8141 const LDKCResult_COption_EventZDecodeErrorZ* operator ->() const { return &self; }
8143 class CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ {
8145 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ self;
8147 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(const CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&) = delete;
8148 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
8149 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); }
8150 operator LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() && { LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ)); return res; }
8151 ~CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ() { CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(self); }
8152 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; }
8153 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() { return &self; }
8154 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() { return &self; }
8155 const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator &() const { return &self; }
8156 const LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* operator ->() const { return &self; }
8158 class CResult_PaymentFailureReasonDecodeErrorZ {
8160 LDKCResult_PaymentFailureReasonDecodeErrorZ self;
8162 CResult_PaymentFailureReasonDecodeErrorZ(const CResult_PaymentFailureReasonDecodeErrorZ&) = delete;
8163 CResult_PaymentFailureReasonDecodeErrorZ(CResult_PaymentFailureReasonDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); }
8164 CResult_PaymentFailureReasonDecodeErrorZ(LDKCResult_PaymentFailureReasonDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); }
8165 operator LDKCResult_PaymentFailureReasonDecodeErrorZ() && { LDKCResult_PaymentFailureReasonDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ)); return res; }
8166 ~CResult_PaymentFailureReasonDecodeErrorZ() { CResult_PaymentFailureReasonDecodeErrorZ_free(self); }
8167 CResult_PaymentFailureReasonDecodeErrorZ& operator=(CResult_PaymentFailureReasonDecodeErrorZ&& o) { CResult_PaymentFailureReasonDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentFailureReasonDecodeErrorZ)); return *this; }
8168 LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() { return &self; }
8169 LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() { return &self; }
8170 const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator &() const { return &self; }
8171 const LDKCResult_PaymentFailureReasonDecodeErrorZ* operator ->() const { return &self; }
8173 class COption_SocketAddressZ {
8175 LDKCOption_SocketAddressZ self;
8177 COption_SocketAddressZ(const COption_SocketAddressZ&) = delete;
8178 COption_SocketAddressZ(COption_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SocketAddressZ)); }
8179 COption_SocketAddressZ(LDKCOption_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SocketAddressZ)); }
8180 operator LDKCOption_SocketAddressZ() && { LDKCOption_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCOption_SocketAddressZ)); return res; }
8181 ~COption_SocketAddressZ() { COption_SocketAddressZ_free(self); }
8182 COption_SocketAddressZ& operator=(COption_SocketAddressZ&& o) { COption_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SocketAddressZ)); return *this; }
8183 LDKCOption_SocketAddressZ* operator &() { return &self; }
8184 LDKCOption_SocketAddressZ* operator ->() { return &self; }
8185 const LDKCOption_SocketAddressZ* operator &() const { return &self; }
8186 const LDKCOption_SocketAddressZ* operator ->() const { return &self; }
8188 class CResult_COption_MonitorEventZDecodeErrorZ {
8190 LDKCResult_COption_MonitorEventZDecodeErrorZ self;
8192 CResult_COption_MonitorEventZDecodeErrorZ(const CResult_COption_MonitorEventZDecodeErrorZ&) = delete;
8193 CResult_COption_MonitorEventZDecodeErrorZ(CResult_COption_MonitorEventZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_MonitorEventZDecodeErrorZ)); }
8194 CResult_COption_MonitorEventZDecodeErrorZ(LDKCResult_COption_MonitorEventZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); }
8195 operator LDKCResult_COption_MonitorEventZDecodeErrorZ() && { LDKCResult_COption_MonitorEventZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ)); return res; }
8196 ~CResult_COption_MonitorEventZDecodeErrorZ() { CResult_COption_MonitorEventZDecodeErrorZ_free(self); }
8197 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; }
8198 LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() { return &self; }
8199 LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() { return &self; }
8200 const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator &() const { return &self; }
8201 const LDKCResult_COption_MonitorEventZDecodeErrorZ* operator ->() const { return &self; }
8203 class COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ {
8205 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ self;
8207 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(const COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&) = delete;
8208 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
8209 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); }
8210 operator LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() && { LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ)); return res; }
8211 ~COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ() { COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(self); }
8212 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; }
8213 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() { return &self; }
8214 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() { return &self; }
8215 const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator &() const { return &self; }
8216 const LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ* operator ->() const { return &self; }
8218 class CResult_DescriptionCreationErrorZ {
8220 LDKCResult_DescriptionCreationErrorZ self;
8222 CResult_DescriptionCreationErrorZ(const CResult_DescriptionCreationErrorZ&) = delete;
8223 CResult_DescriptionCreationErrorZ(CResult_DescriptionCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); }
8224 CResult_DescriptionCreationErrorZ(LDKCResult_DescriptionCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); }
8225 operator LDKCResult_DescriptionCreationErrorZ() && { LDKCResult_DescriptionCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DescriptionCreationErrorZ)); return res; }
8226 ~CResult_DescriptionCreationErrorZ() { CResult_DescriptionCreationErrorZ_free(self); }
8227 CResult_DescriptionCreationErrorZ& operator=(CResult_DescriptionCreationErrorZ&& o) { CResult_DescriptionCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DescriptionCreationErrorZ)); return *this; }
8228 LDKCResult_DescriptionCreationErrorZ* operator &() { return &self; }
8229 LDKCResult_DescriptionCreationErrorZ* operator ->() { return &self; }
8230 const LDKCResult_DescriptionCreationErrorZ* operator &() const { return &self; }
8231 const LDKCResult_DescriptionCreationErrorZ* operator ->() const { return &self; }
8233 class CResult_RoutingFeesDecodeErrorZ {
8235 LDKCResult_RoutingFeesDecodeErrorZ self;
8237 CResult_RoutingFeesDecodeErrorZ(const CResult_RoutingFeesDecodeErrorZ&) = delete;
8238 CResult_RoutingFeesDecodeErrorZ(CResult_RoutingFeesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); }
8239 CResult_RoutingFeesDecodeErrorZ(LDKCResult_RoutingFeesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); }
8240 operator LDKCResult_RoutingFeesDecodeErrorZ() && { LDKCResult_RoutingFeesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RoutingFeesDecodeErrorZ)); return res; }
8241 ~CResult_RoutingFeesDecodeErrorZ() { CResult_RoutingFeesDecodeErrorZ_free(self); }
8242 CResult_RoutingFeesDecodeErrorZ& operator=(CResult_RoutingFeesDecodeErrorZ&& o) { CResult_RoutingFeesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RoutingFeesDecodeErrorZ)); return *this; }
8243 LDKCResult_RoutingFeesDecodeErrorZ* operator &() { return &self; }
8244 LDKCResult_RoutingFeesDecodeErrorZ* operator ->() { return &self; }
8245 const LDKCResult_RoutingFeesDecodeErrorZ* operator &() const { return &self; }
8246 const LDKCResult_RoutingFeesDecodeErrorZ* operator ->() const { return &self; }
8248 class CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ {
8250 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ self;
8252 CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ(const CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ&) = delete;
8253 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)); }
8254 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)); }
8255 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; }
8256 ~CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ() { CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(self); }
8257 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; }
8258 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() { return &self; }
8259 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() { return &self; }
8260 const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator &() const { return &self; }
8261 const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ* operator ->() const { return &self; }
8263 class CResult_PaymentRelayDecodeErrorZ {
8265 LDKCResult_PaymentRelayDecodeErrorZ self;
8267 CResult_PaymentRelayDecodeErrorZ(const CResult_PaymentRelayDecodeErrorZ&) = delete;
8268 CResult_PaymentRelayDecodeErrorZ(CResult_PaymentRelayDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); }
8269 CResult_PaymentRelayDecodeErrorZ(LDKCResult_PaymentRelayDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); }
8270 operator LDKCResult_PaymentRelayDecodeErrorZ() && { LDKCResult_PaymentRelayDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentRelayDecodeErrorZ)); return res; }
8271 ~CResult_PaymentRelayDecodeErrorZ() { CResult_PaymentRelayDecodeErrorZ_free(self); }
8272 CResult_PaymentRelayDecodeErrorZ& operator=(CResult_PaymentRelayDecodeErrorZ&& o) { CResult_PaymentRelayDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentRelayDecodeErrorZ)); return *this; }
8273 LDKCResult_PaymentRelayDecodeErrorZ* operator &() { return &self; }
8274 LDKCResult_PaymentRelayDecodeErrorZ* operator ->() { return &self; }
8275 const LDKCResult_PaymentRelayDecodeErrorZ* operator &() const { return &self; }
8276 const LDKCResult_PaymentRelayDecodeErrorZ* operator ->() const { return &self; }
8278 class CResult_QueryShortChannelIdsDecodeErrorZ {
8280 LDKCResult_QueryShortChannelIdsDecodeErrorZ self;
8282 CResult_QueryShortChannelIdsDecodeErrorZ(const CResult_QueryShortChannelIdsDecodeErrorZ&) = delete;
8283 CResult_QueryShortChannelIdsDecodeErrorZ(CResult_QueryShortChannelIdsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); }
8284 CResult_QueryShortChannelIdsDecodeErrorZ(LDKCResult_QueryShortChannelIdsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); }
8285 operator LDKCResult_QueryShortChannelIdsDecodeErrorZ() && { LDKCResult_QueryShortChannelIdsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ)); return res; }
8286 ~CResult_QueryShortChannelIdsDecodeErrorZ() { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); }
8287 CResult_QueryShortChannelIdsDecodeErrorZ& operator=(CResult_QueryShortChannelIdsDecodeErrorZ&& o) { CResult_QueryShortChannelIdsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_QueryShortChannelIdsDecodeErrorZ)); return *this; }
8288 LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() { return &self; }
8289 LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() { return &self; }
8290 const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator &() const { return &self; }
8291 const LDKCResult_QueryShortChannelIdsDecodeErrorZ* operator ->() const { return &self; }
8293 class CResult_VerifiedInvoiceRequestNoneZ {
8295 LDKCResult_VerifiedInvoiceRequestNoneZ self;
8297 CResult_VerifiedInvoiceRequestNoneZ(const CResult_VerifiedInvoiceRequestNoneZ&) = delete;
8298 CResult_VerifiedInvoiceRequestNoneZ(CResult_VerifiedInvoiceRequestNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); }
8299 CResult_VerifiedInvoiceRequestNoneZ(LDKCResult_VerifiedInvoiceRequestNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); }
8300 operator LDKCResult_VerifiedInvoiceRequestNoneZ() && { LDKCResult_VerifiedInvoiceRequestNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ)); return res; }
8301 ~CResult_VerifiedInvoiceRequestNoneZ() { CResult_VerifiedInvoiceRequestNoneZ_free(self); }
8302 CResult_VerifiedInvoiceRequestNoneZ& operator=(CResult_VerifiedInvoiceRequestNoneZ&& o) { CResult_VerifiedInvoiceRequestNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_VerifiedInvoiceRequestNoneZ)); return *this; }
8303 LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() { return &self; }
8304 LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() { return &self; }
8305 const LDKCResult_VerifiedInvoiceRequestNoneZ* operator &() const { return &self; }
8306 const LDKCResult_VerifiedInvoiceRequestNoneZ* operator ->() const { return &self; }
8308 class CResult_UpdateAddHTLCDecodeErrorZ {
8310 LDKCResult_UpdateAddHTLCDecodeErrorZ self;
8312 CResult_UpdateAddHTLCDecodeErrorZ(const CResult_UpdateAddHTLCDecodeErrorZ&) = delete;
8313 CResult_UpdateAddHTLCDecodeErrorZ(CResult_UpdateAddHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); }
8314 CResult_UpdateAddHTLCDecodeErrorZ(LDKCResult_UpdateAddHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); }
8315 operator LDKCResult_UpdateAddHTLCDecodeErrorZ() && { LDKCResult_UpdateAddHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ)); return res; }
8316 ~CResult_UpdateAddHTLCDecodeErrorZ() { CResult_UpdateAddHTLCDecodeErrorZ_free(self); }
8317 CResult_UpdateAddHTLCDecodeErrorZ& operator=(CResult_UpdateAddHTLCDecodeErrorZ&& o) { CResult_UpdateAddHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateAddHTLCDecodeErrorZ)); return *this; }
8318 LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() { return &self; }
8319 LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() { return &self; }
8320 const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator &() const { return &self; }
8321 const LDKCResult_UpdateAddHTLCDecodeErrorZ* operator ->() const { return &self; }
8323 class COption_MonitorEventZ {
8325 LDKCOption_MonitorEventZ self;
8327 COption_MonitorEventZ(const COption_MonitorEventZ&) = delete;
8328 COption_MonitorEventZ(COption_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_MonitorEventZ)); }
8329 COption_MonitorEventZ(LDKCOption_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_MonitorEventZ)); }
8330 operator LDKCOption_MonitorEventZ() && { LDKCOption_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCOption_MonitorEventZ)); return res; }
8331 ~COption_MonitorEventZ() { COption_MonitorEventZ_free(self); }
8332 COption_MonitorEventZ& operator=(COption_MonitorEventZ&& o) { COption_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_MonitorEventZ)); return *this; }
8333 LDKCOption_MonitorEventZ* operator &() { return &self; }
8334 LDKCOption_MonitorEventZ* operator ->() { return &self; }
8335 const LDKCOption_MonitorEventZ* operator &() const { return &self; }
8336 const LDKCOption_MonitorEventZ* operator ->() const { return &self; }
8338 class COption_TypeZ {
8340 LDKCOption_TypeZ self;
8342 COption_TypeZ(const COption_TypeZ&) = delete;
8343 COption_TypeZ(COption_TypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TypeZ)); }
8344 COption_TypeZ(LDKCOption_TypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TypeZ)); }
8345 operator LDKCOption_TypeZ() && { LDKCOption_TypeZ res = self; memset(&self, 0, sizeof(LDKCOption_TypeZ)); return res; }
8346 ~COption_TypeZ() { COption_TypeZ_free(self); }
8347 COption_TypeZ& operator=(COption_TypeZ&& o) { COption_TypeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TypeZ)); return *this; }
8348 LDKCOption_TypeZ* operator &() { return &self; }
8349 LDKCOption_TypeZ* operator ->() { return &self; }
8350 const LDKCOption_TypeZ* operator &() const { return &self; }
8351 const LDKCOption_TypeZ* operator ->() const { return &self; }
8353 class CResult_COption_TypeZDecodeErrorZ {
8355 LDKCResult_COption_TypeZDecodeErrorZ self;
8357 CResult_COption_TypeZDecodeErrorZ(const CResult_COption_TypeZDecodeErrorZ&) = delete;
8358 CResult_COption_TypeZDecodeErrorZ(CResult_COption_TypeZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_TypeZDecodeErrorZ)); }
8359 CResult_COption_TypeZDecodeErrorZ(LDKCResult_COption_TypeZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); }
8360 operator LDKCResult_COption_TypeZDecodeErrorZ() && { LDKCResult_COption_TypeZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_TypeZDecodeErrorZ)); return res; }
8361 ~CResult_COption_TypeZDecodeErrorZ() { CResult_COption_TypeZDecodeErrorZ_free(self); }
8362 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; }
8363 LDKCResult_COption_TypeZDecodeErrorZ* operator &() { return &self; }
8364 LDKCResult_COption_TypeZDecodeErrorZ* operator ->() { return &self; }
8365 const LDKCResult_COption_TypeZDecodeErrorZ* operator &() const { return &self; }
8366 const LDKCResult_COption_TypeZDecodeErrorZ* operator ->() const { return &self; }
8368 class CResult_COption_PathFailureZDecodeErrorZ {
8370 LDKCResult_COption_PathFailureZDecodeErrorZ self;
8372 CResult_COption_PathFailureZDecodeErrorZ(const CResult_COption_PathFailureZDecodeErrorZ&) = delete;
8373 CResult_COption_PathFailureZDecodeErrorZ(CResult_COption_PathFailureZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_PathFailureZDecodeErrorZ)); }
8374 CResult_COption_PathFailureZDecodeErrorZ(LDKCResult_COption_PathFailureZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); }
8375 operator LDKCResult_COption_PathFailureZDecodeErrorZ() && { LDKCResult_COption_PathFailureZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ)); return res; }
8376 ~CResult_COption_PathFailureZDecodeErrorZ() { CResult_COption_PathFailureZDecodeErrorZ_free(self); }
8377 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; }
8378 LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() { return &self; }
8379 LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() { return &self; }
8380 const LDKCResult_COption_PathFailureZDecodeErrorZ* operator &() const { return &self; }
8381 const LDKCResult_COption_PathFailureZDecodeErrorZ* operator ->() const { return &self; }
8383 class CResult_Bolt11InvoiceSignOrCreationErrorZ {
8385 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ self;
8387 CResult_Bolt11InvoiceSignOrCreationErrorZ(const CResult_Bolt11InvoiceSignOrCreationErrorZ&) = delete;
8388 CResult_Bolt11InvoiceSignOrCreationErrorZ(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); }
8389 CResult_Bolt11InvoiceSignOrCreationErrorZ(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); }
8390 operator LDKCResult_Bolt11InvoiceSignOrCreationErrorZ() && { LDKCResult_Bolt11InvoiceSignOrCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ)); return res; }
8391 ~CResult_Bolt11InvoiceSignOrCreationErrorZ() { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); }
8392 CResult_Bolt11InvoiceSignOrCreationErrorZ& operator=(CResult_Bolt11InvoiceSignOrCreationErrorZ&& o) { CResult_Bolt11InvoiceSignOrCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceSignOrCreationErrorZ)); return *this; }
8393 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() { return &self; }
8394 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() { return &self; }
8395 const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator &() const { return &self; }
8396 const LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* operator ->() const { return &self; }
8398 class CResult_UpdateFailHTLCDecodeErrorZ {
8400 LDKCResult_UpdateFailHTLCDecodeErrorZ self;
8402 CResult_UpdateFailHTLCDecodeErrorZ(const CResult_UpdateFailHTLCDecodeErrorZ&) = delete;
8403 CResult_UpdateFailHTLCDecodeErrorZ(CResult_UpdateFailHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); }
8404 CResult_UpdateFailHTLCDecodeErrorZ(LDKCResult_UpdateFailHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); }
8405 operator LDKCResult_UpdateFailHTLCDecodeErrorZ() && { LDKCResult_UpdateFailHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ)); return res; }
8406 ~CResult_UpdateFailHTLCDecodeErrorZ() { CResult_UpdateFailHTLCDecodeErrorZ_free(self); }
8407 CResult_UpdateFailHTLCDecodeErrorZ& operator=(CResult_UpdateFailHTLCDecodeErrorZ&& o) { CResult_UpdateFailHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailHTLCDecodeErrorZ)); return *this; }
8408 LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() { return &self; }
8409 LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() { return &self; }
8410 const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator &() const { return &self; }
8411 const LDKCResult_UpdateFailHTLCDecodeErrorZ* operator ->() const { return &self; }
8413 class CResult_CVec_BlindedPathZNoneZ {
8415 LDKCResult_CVec_BlindedPathZNoneZ self;
8417 CResult_CVec_BlindedPathZNoneZ(const CResult_CVec_BlindedPathZNoneZ&) = delete;
8418 CResult_CVec_BlindedPathZNoneZ(CResult_CVec_BlindedPathZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); }
8419 CResult_CVec_BlindedPathZNoneZ(LDKCResult_CVec_BlindedPathZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); }
8420 operator LDKCResult_CVec_BlindedPathZNoneZ() && { LDKCResult_CVec_BlindedPathZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_BlindedPathZNoneZ)); return res; }
8421 ~CResult_CVec_BlindedPathZNoneZ() { CResult_CVec_BlindedPathZNoneZ_free(self); }
8422 CResult_CVec_BlindedPathZNoneZ& operator=(CResult_CVec_BlindedPathZNoneZ&& o) { CResult_CVec_BlindedPathZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_BlindedPathZNoneZ)); return *this; }
8423 LDKCResult_CVec_BlindedPathZNoneZ* operator &() { return &self; }
8424 LDKCResult_CVec_BlindedPathZNoneZ* operator ->() { return &self; }
8425 const LDKCResult_CVec_BlindedPathZNoneZ* operator &() const { return &self; }
8426 const LDKCResult_CVec_BlindedPathZNoneZ* operator ->() const { return &self; }
8428 class CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ {
8430 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ self;
8432 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(const CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&) = delete;
8433 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
8434 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); }
8435 operator LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ)); return res; }
8436 ~CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ() { CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(self); }
8437 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; }
8438 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() { return &self; }
8439 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() { return &self; }
8440 const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator &() const { return &self; }
8441 const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ* operator ->() const { return &self; }
8443 class CResult_RevokeAndACKDecodeErrorZ {
8445 LDKCResult_RevokeAndACKDecodeErrorZ self;
8447 CResult_RevokeAndACKDecodeErrorZ(const CResult_RevokeAndACKDecodeErrorZ&) = delete;
8448 CResult_RevokeAndACKDecodeErrorZ(CResult_RevokeAndACKDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); }
8449 CResult_RevokeAndACKDecodeErrorZ(LDKCResult_RevokeAndACKDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); }
8450 operator LDKCResult_RevokeAndACKDecodeErrorZ() && { LDKCResult_RevokeAndACKDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevokeAndACKDecodeErrorZ)); return res; }
8451 ~CResult_RevokeAndACKDecodeErrorZ() { CResult_RevokeAndACKDecodeErrorZ_free(self); }
8452 CResult_RevokeAndACKDecodeErrorZ& operator=(CResult_RevokeAndACKDecodeErrorZ&& o) { CResult_RevokeAndACKDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevokeAndACKDecodeErrorZ)); return *this; }
8453 LDKCResult_RevokeAndACKDecodeErrorZ* operator &() { return &self; }
8454 LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() { return &self; }
8455 const LDKCResult_RevokeAndACKDecodeErrorZ* operator &() const { return &self; }
8456 const LDKCResult_RevokeAndACKDecodeErrorZ* operator ->() const { return &self; }
8458 class CResult_SpendableOutputDescriptorDecodeErrorZ {
8460 LDKCResult_SpendableOutputDescriptorDecodeErrorZ self;
8462 CResult_SpendableOutputDescriptorDecodeErrorZ(const CResult_SpendableOutputDescriptorDecodeErrorZ&) = delete;
8463 CResult_SpendableOutputDescriptorDecodeErrorZ(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); }
8464 CResult_SpendableOutputDescriptorDecodeErrorZ(LDKCResult_SpendableOutputDescriptorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); }
8465 operator LDKCResult_SpendableOutputDescriptorDecodeErrorZ() && { LDKCResult_SpendableOutputDescriptorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ)); return res; }
8466 ~CResult_SpendableOutputDescriptorDecodeErrorZ() { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); }
8467 CResult_SpendableOutputDescriptorDecodeErrorZ& operator=(CResult_SpendableOutputDescriptorDecodeErrorZ&& o) { CResult_SpendableOutputDescriptorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpendableOutputDescriptorDecodeErrorZ)); return *this; }
8468 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() { return &self; }
8469 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() { return &self; }
8470 const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator &() const { return &self; }
8471 const LDKCResult_SpendableOutputDescriptorDecodeErrorZ* operator ->() const { return &self; }
8473 class C2Tuple_PublicKeyCOption_SocketAddressZZ {
8475 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ self;
8477 C2Tuple_PublicKeyCOption_SocketAddressZZ(const C2Tuple_PublicKeyCOption_SocketAddressZZ&) = delete;
8478 C2Tuple_PublicKeyCOption_SocketAddressZZ(C2Tuple_PublicKeyCOption_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyCOption_SocketAddressZZ)); }
8479 C2Tuple_PublicKeyCOption_SocketAddressZZ(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); }
8480 operator LDKC2Tuple_PublicKeyCOption_SocketAddressZZ() && { LDKC2Tuple_PublicKeyCOption_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ)); return res; }
8481 ~C2Tuple_PublicKeyCOption_SocketAddressZZ() { C2Tuple_PublicKeyCOption_SocketAddressZZ_free(self); }
8482 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; }
8483 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() { return &self; }
8484 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() { return &self; }
8485 const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator &() const { return &self; }
8486 const LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* operator ->() const { return &self; }
8488 class CResult_UnsignedChannelUpdateDecodeErrorZ {
8490 LDKCResult_UnsignedChannelUpdateDecodeErrorZ self;
8492 CResult_UnsignedChannelUpdateDecodeErrorZ(const CResult_UnsignedChannelUpdateDecodeErrorZ&) = delete;
8493 CResult_UnsignedChannelUpdateDecodeErrorZ(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); }
8494 CResult_UnsignedChannelUpdateDecodeErrorZ(LDKCResult_UnsignedChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); }
8495 operator LDKCResult_UnsignedChannelUpdateDecodeErrorZ() && { LDKCResult_UnsignedChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ)); return res; }
8496 ~CResult_UnsignedChannelUpdateDecodeErrorZ() { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); }
8497 CResult_UnsignedChannelUpdateDecodeErrorZ& operator=(CResult_UnsignedChannelUpdateDecodeErrorZ&& o) { CResult_UnsignedChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedChannelUpdateDecodeErrorZ)); return *this; }
8498 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() { return &self; }
8499 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() { return &self; }
8500 const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator &() const { return &self; }
8501 const LDKCResult_UnsignedChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
8503 class CResult_PayeePubKeySecp256k1ErrorZ {
8505 LDKCResult_PayeePubKeySecp256k1ErrorZ self;
8507 CResult_PayeePubKeySecp256k1ErrorZ(const CResult_PayeePubKeySecp256k1ErrorZ&) = delete;
8508 CResult_PayeePubKeySecp256k1ErrorZ(CResult_PayeePubKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); }
8509 CResult_PayeePubKeySecp256k1ErrorZ(LDKCResult_PayeePubKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); }
8510 operator LDKCResult_PayeePubKeySecp256k1ErrorZ() && { LDKCResult_PayeePubKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ)); return res; }
8511 ~CResult_PayeePubKeySecp256k1ErrorZ() { CResult_PayeePubKeySecp256k1ErrorZ_free(self); }
8512 CResult_PayeePubKeySecp256k1ErrorZ& operator=(CResult_PayeePubKeySecp256k1ErrorZ&& o) { CResult_PayeePubKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PayeePubKeySecp256k1ErrorZ)); return *this; }
8513 LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() { return &self; }
8514 LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() { return &self; }
8515 const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator &() const { return &self; }
8516 const LDKCResult_PayeePubKeySecp256k1ErrorZ* operator ->() const { return &self; }
8518 class C2Tuple__u832u16Z {
8520 LDKC2Tuple__u832u16Z self;
8522 C2Tuple__u832u16Z(const C2Tuple__u832u16Z&) = delete;
8523 C2Tuple__u832u16Z(C2Tuple__u832u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple__u832u16Z)); }
8524 C2Tuple__u832u16Z(LDKC2Tuple__u832u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple__u832u16Z)); }
8525 operator LDKC2Tuple__u832u16Z() && { LDKC2Tuple__u832u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple__u832u16Z)); return res; }
8526 ~C2Tuple__u832u16Z() { C2Tuple__u832u16Z_free(self); }
8527 C2Tuple__u832u16Z& operator=(C2Tuple__u832u16Z&& o) { C2Tuple__u832u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple__u832u16Z)); return *this; }
8528 LDKC2Tuple__u832u16Z* operator &() { return &self; }
8529 LDKC2Tuple__u832u16Z* operator ->() { return &self; }
8530 const LDKC2Tuple__u832u16Z* operator &() const { return &self; }
8531 const LDKC2Tuple__u832u16Z* operator ->() const { return &self; }
8533 class COption_BigEndianScalarZ {
8535 LDKCOption_BigEndianScalarZ self;
8537 COption_BigEndianScalarZ(const COption_BigEndianScalarZ&) = delete;
8538 COption_BigEndianScalarZ(COption_BigEndianScalarZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_BigEndianScalarZ)); }
8539 COption_BigEndianScalarZ(LDKCOption_BigEndianScalarZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_BigEndianScalarZ)); }
8540 operator LDKCOption_BigEndianScalarZ() && { LDKCOption_BigEndianScalarZ res = self; memset(&self, 0, sizeof(LDKCOption_BigEndianScalarZ)); return res; }
8541 ~COption_BigEndianScalarZ() { COption_BigEndianScalarZ_free(self); }
8542 COption_BigEndianScalarZ& operator=(COption_BigEndianScalarZ&& o) { COption_BigEndianScalarZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_BigEndianScalarZ)); return *this; }
8543 LDKCOption_BigEndianScalarZ* operator &() { return &self; }
8544 LDKCOption_BigEndianScalarZ* operator ->() { return &self; }
8545 const LDKCOption_BigEndianScalarZ* operator &() const { return &self; }
8546 const LDKCOption_BigEndianScalarZ* operator ->() const { return &self; }
8548 class CResult_PublicKeySecp256k1ErrorZ {
8550 LDKCResult_PublicKeySecp256k1ErrorZ self;
8552 CResult_PublicKeySecp256k1ErrorZ(const CResult_PublicKeySecp256k1ErrorZ&) = delete;
8553 CResult_PublicKeySecp256k1ErrorZ(CResult_PublicKeySecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); }
8554 CResult_PublicKeySecp256k1ErrorZ(LDKCResult_PublicKeySecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); }
8555 operator LDKCResult_PublicKeySecp256k1ErrorZ() && { LDKCResult_PublicKeySecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeySecp256k1ErrorZ)); return res; }
8556 ~CResult_PublicKeySecp256k1ErrorZ() { CResult_PublicKeySecp256k1ErrorZ_free(self); }
8557 CResult_PublicKeySecp256k1ErrorZ& operator=(CResult_PublicKeySecp256k1ErrorZ&& o) { CResult_PublicKeySecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeySecp256k1ErrorZ)); return *this; }
8558 LDKCResult_PublicKeySecp256k1ErrorZ* operator &() { return &self; }
8559 LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() { return &self; }
8560 const LDKCResult_PublicKeySecp256k1ErrorZ* operator &() const { return &self; }
8561 const LDKCResult_PublicKeySecp256k1ErrorZ* operator ->() const { return &self; }
8563 class CResult_CVec_ECDSASignatureZNoneZ {
8565 LDKCResult_CVec_ECDSASignatureZNoneZ self;
8567 CResult_CVec_ECDSASignatureZNoneZ(const CResult_CVec_ECDSASignatureZNoneZ&) = delete;
8568 CResult_CVec_ECDSASignatureZNoneZ(CResult_CVec_ECDSASignatureZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_ECDSASignatureZNoneZ)); }
8569 CResult_CVec_ECDSASignatureZNoneZ(LDKCResult_CVec_ECDSASignatureZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); }
8570 operator LDKCResult_CVec_ECDSASignatureZNoneZ() && { LDKCResult_CVec_ECDSASignatureZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ)); return res; }
8571 ~CResult_CVec_ECDSASignatureZNoneZ() { CResult_CVec_ECDSASignatureZNoneZ_free(self); }
8572 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; }
8573 LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() { return &self; }
8574 LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() { return &self; }
8575 const LDKCResult_CVec_ECDSASignatureZNoneZ* operator &() const { return &self; }
8576 const LDKCResult_CVec_ECDSASignatureZNoneZ* operator ->() const { return &self; }
8578 class CVec_BlindedHopZ {
8580 LDKCVec_BlindedHopZ self;
8582 CVec_BlindedHopZ(const CVec_BlindedHopZ&) = delete;
8583 CVec_BlindedHopZ(CVec_BlindedHopZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BlindedHopZ)); }
8584 CVec_BlindedHopZ(LDKCVec_BlindedHopZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BlindedHopZ)); }
8585 operator LDKCVec_BlindedHopZ() && { LDKCVec_BlindedHopZ res = self; memset(&self, 0, sizeof(LDKCVec_BlindedHopZ)); return res; }
8586 ~CVec_BlindedHopZ() { CVec_BlindedHopZ_free(self); }
8587 CVec_BlindedHopZ& operator=(CVec_BlindedHopZ&& o) { CVec_BlindedHopZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BlindedHopZ)); return *this; }
8588 LDKCVec_BlindedHopZ* operator &() { return &self; }
8589 LDKCVec_BlindedHopZ* operator ->() { return &self; }
8590 const LDKCVec_BlindedHopZ* operator &() const { return &self; }
8591 const LDKCVec_BlindedHopZ* operator ->() const { return &self; }
8593 class CResult_COption_ClosureReasonZDecodeErrorZ {
8595 LDKCResult_COption_ClosureReasonZDecodeErrorZ self;
8597 CResult_COption_ClosureReasonZDecodeErrorZ(const CResult_COption_ClosureReasonZDecodeErrorZ&) = delete;
8598 CResult_COption_ClosureReasonZDecodeErrorZ(CResult_COption_ClosureReasonZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_ClosureReasonZDecodeErrorZ)); }
8599 CResult_COption_ClosureReasonZDecodeErrorZ(LDKCResult_COption_ClosureReasonZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); }
8600 operator LDKCResult_COption_ClosureReasonZDecodeErrorZ() && { LDKCResult_COption_ClosureReasonZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ)); return res; }
8601 ~CResult_COption_ClosureReasonZDecodeErrorZ() { CResult_COption_ClosureReasonZDecodeErrorZ_free(self); }
8602 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; }
8603 LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() { return &self; }
8604 LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() { return &self; }
8605 const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator &() const { return &self; }
8606 const LDKCResult_COption_ClosureReasonZDecodeErrorZ* operator ->() const { return &self; }
8608 class CResult_InvoiceErrorDecodeErrorZ {
8610 LDKCResult_InvoiceErrorDecodeErrorZ self;
8612 CResult_InvoiceErrorDecodeErrorZ(const CResult_InvoiceErrorDecodeErrorZ&) = delete;
8613 CResult_InvoiceErrorDecodeErrorZ(CResult_InvoiceErrorDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); }
8614 CResult_InvoiceErrorDecodeErrorZ(LDKCResult_InvoiceErrorDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); }
8615 operator LDKCResult_InvoiceErrorDecodeErrorZ() && { LDKCResult_InvoiceErrorDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InvoiceErrorDecodeErrorZ)); return res; }
8616 ~CResult_InvoiceErrorDecodeErrorZ() { CResult_InvoiceErrorDecodeErrorZ_free(self); }
8617 CResult_InvoiceErrorDecodeErrorZ& operator=(CResult_InvoiceErrorDecodeErrorZ&& o) { CResult_InvoiceErrorDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InvoiceErrorDecodeErrorZ)); return *this; }
8618 LDKCResult_InvoiceErrorDecodeErrorZ* operator &() { return &self; }
8619 LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() { return &self; }
8620 const LDKCResult_InvoiceErrorDecodeErrorZ* operator &() const { return &self; }
8621 const LDKCResult_InvoiceErrorDecodeErrorZ* operator ->() const { return &self; }
8623 class C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ {
8625 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ self;
8627 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(const C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&) = delete;
8628 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
8629 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); }
8630 operator LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() && { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return res; }
8631 ~C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ() { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); }
8632 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ& operator=(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ&& o) { C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ)); return *this; }
8633 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() { return &self; }
8634 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() { return &self; }
8635 const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator &() const { return &self; }
8636 const LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* operator ->() const { return &self; }
8638 class CResult_RouteParametersDecodeErrorZ {
8640 LDKCResult_RouteParametersDecodeErrorZ self;
8642 CResult_RouteParametersDecodeErrorZ(const CResult_RouteParametersDecodeErrorZ&) = delete;
8643 CResult_RouteParametersDecodeErrorZ(CResult_RouteParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); }
8644 CResult_RouteParametersDecodeErrorZ(LDKCResult_RouteParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); }
8645 operator LDKCResult_RouteParametersDecodeErrorZ() && { LDKCResult_RouteParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteParametersDecodeErrorZ)); return res; }
8646 ~CResult_RouteParametersDecodeErrorZ() { CResult_RouteParametersDecodeErrorZ_free(self); }
8647 CResult_RouteParametersDecodeErrorZ& operator=(CResult_RouteParametersDecodeErrorZ&& o) { CResult_RouteParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteParametersDecodeErrorZ)); return *this; }
8648 LDKCResult_RouteParametersDecodeErrorZ* operator &() { return &self; }
8649 LDKCResult_RouteParametersDecodeErrorZ* operator ->() { return &self; }
8650 const LDKCResult_RouteParametersDecodeErrorZ* operator &() const { return &self; }
8651 const LDKCResult_RouteParametersDecodeErrorZ* operator ->() const { return &self; }
8653 class CResult_PrivateRouteCreationErrorZ {
8655 LDKCResult_PrivateRouteCreationErrorZ self;
8657 CResult_PrivateRouteCreationErrorZ(const CResult_PrivateRouteCreationErrorZ&) = delete;
8658 CResult_PrivateRouteCreationErrorZ(CResult_PrivateRouteCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); }
8659 CResult_PrivateRouteCreationErrorZ(LDKCResult_PrivateRouteCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); }
8660 operator LDKCResult_PrivateRouteCreationErrorZ() && { LDKCResult_PrivateRouteCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PrivateRouteCreationErrorZ)); return res; }
8661 ~CResult_PrivateRouteCreationErrorZ() { CResult_PrivateRouteCreationErrorZ_free(self); }
8662 CResult_PrivateRouteCreationErrorZ& operator=(CResult_PrivateRouteCreationErrorZ&& o) { CResult_PrivateRouteCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PrivateRouteCreationErrorZ)); return *this; }
8663 LDKCResult_PrivateRouteCreationErrorZ* operator &() { return &self; }
8664 LDKCResult_PrivateRouteCreationErrorZ* operator ->() { return &self; }
8665 const LDKCResult_PrivateRouteCreationErrorZ* operator &() const { return &self; }
8666 const LDKCResult_PrivateRouteCreationErrorZ* operator ->() const { return &self; }
8668 class CResult_NodeAliasDecodeErrorZ {
8670 LDKCResult_NodeAliasDecodeErrorZ self;
8672 CResult_NodeAliasDecodeErrorZ(const CResult_NodeAliasDecodeErrorZ&) = delete;
8673 CResult_NodeAliasDecodeErrorZ(CResult_NodeAliasDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); }
8674 CResult_NodeAliasDecodeErrorZ(LDKCResult_NodeAliasDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); }
8675 operator LDKCResult_NodeAliasDecodeErrorZ() && { LDKCResult_NodeAliasDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAliasDecodeErrorZ)); return res; }
8676 ~CResult_NodeAliasDecodeErrorZ() { CResult_NodeAliasDecodeErrorZ_free(self); }
8677 CResult_NodeAliasDecodeErrorZ& operator=(CResult_NodeAliasDecodeErrorZ&& o) { CResult_NodeAliasDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAliasDecodeErrorZ)); return *this; }
8678 LDKCResult_NodeAliasDecodeErrorZ* operator &() { return &self; }
8679 LDKCResult_NodeAliasDecodeErrorZ* operator ->() { return &self; }
8680 const LDKCResult_NodeAliasDecodeErrorZ* operator &() const { return &self; }
8681 const LDKCResult_NodeAliasDecodeErrorZ* operator ->() const { return &self; }
8683 class CVec_UpdateFulfillHTLCZ {
8685 LDKCVec_UpdateFulfillHTLCZ self;
8687 CVec_UpdateFulfillHTLCZ(const CVec_UpdateFulfillHTLCZ&) = delete;
8688 CVec_UpdateFulfillHTLCZ(CVec_UpdateFulfillHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); }
8689 CVec_UpdateFulfillHTLCZ(LDKCVec_UpdateFulfillHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); }
8690 operator LDKCVec_UpdateFulfillHTLCZ() && { LDKCVec_UpdateFulfillHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFulfillHTLCZ)); return res; }
8691 ~CVec_UpdateFulfillHTLCZ() { CVec_UpdateFulfillHTLCZ_free(self); }
8692 CVec_UpdateFulfillHTLCZ& operator=(CVec_UpdateFulfillHTLCZ&& o) { CVec_UpdateFulfillHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFulfillHTLCZ)); return *this; }
8693 LDKCVec_UpdateFulfillHTLCZ* operator &() { return &self; }
8694 LDKCVec_UpdateFulfillHTLCZ* operator ->() { return &self; }
8695 const LDKCVec_UpdateFulfillHTLCZ* operator &() const { return &self; }
8696 const LDKCVec_UpdateFulfillHTLCZ* operator ->() const { return &self; }
8698 class CVec_C2Tuple_u32CVec_u8ZZZ {
8700 LDKCVec_C2Tuple_u32CVec_u8ZZZ self;
8702 CVec_C2Tuple_u32CVec_u8ZZZ(const CVec_C2Tuple_u32CVec_u8ZZZ&) = delete;
8703 CVec_C2Tuple_u32CVec_u8ZZZ(CVec_C2Tuple_u32CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u32CVec_u8ZZZ)); }
8704 CVec_C2Tuple_u32CVec_u8ZZZ(LDKCVec_C2Tuple_u32CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); }
8705 operator LDKCVec_C2Tuple_u32CVec_u8ZZZ() && { LDKCVec_C2Tuple_u32CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u32CVec_u8ZZZ)); return res; }
8706 ~CVec_C2Tuple_u32CVec_u8ZZZ() { CVec_C2Tuple_u32CVec_u8ZZZ_free(self); }
8707 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; }
8708 LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() { return &self; }
8709 LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() { return &self; }
8710 const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator &() const { return &self; }
8711 const LDKCVec_C2Tuple_u32CVec_u8ZZZ* operator ->() const { return &self; }
8713 class C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ {
8715 LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ self;
8717 C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(const C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&) = delete;
8718 C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
8719 C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); }
8720 operator LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() && { LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return res; }
8721 ~C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ() { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); }
8722 C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ& operator=(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ&& o) { C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ)); return *this; }
8723 LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() { return &self; }
8724 LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() { return &self; }
8725 const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator &() const { return &self; }
8726 const LDKC3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZ* operator ->() const { return &self; }
8728 class CResult_AnnouncementSignaturesDecodeErrorZ {
8730 LDKCResult_AnnouncementSignaturesDecodeErrorZ self;
8732 CResult_AnnouncementSignaturesDecodeErrorZ(const CResult_AnnouncementSignaturesDecodeErrorZ&) = delete;
8733 CResult_AnnouncementSignaturesDecodeErrorZ(CResult_AnnouncementSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); }
8734 CResult_AnnouncementSignaturesDecodeErrorZ(LDKCResult_AnnouncementSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); }
8735 operator LDKCResult_AnnouncementSignaturesDecodeErrorZ() && { LDKCResult_AnnouncementSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ)); return res; }
8736 ~CResult_AnnouncementSignaturesDecodeErrorZ() { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); }
8737 CResult_AnnouncementSignaturesDecodeErrorZ& operator=(CResult_AnnouncementSignaturesDecodeErrorZ&& o) { CResult_AnnouncementSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AnnouncementSignaturesDecodeErrorZ)); return *this; }
8738 LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() { return &self; }
8739 LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() { return &self; }
8740 const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator &() const { return &self; }
8741 const LDKCResult_AnnouncementSignaturesDecodeErrorZ* operator ->() const { return &self; }
8743 class CResult_TxCompleteDecodeErrorZ {
8745 LDKCResult_TxCompleteDecodeErrorZ self;
8747 CResult_TxCompleteDecodeErrorZ(const CResult_TxCompleteDecodeErrorZ&) = delete;
8748 CResult_TxCompleteDecodeErrorZ(CResult_TxCompleteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); }
8749 CResult_TxCompleteDecodeErrorZ(LDKCResult_TxCompleteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); }
8750 operator LDKCResult_TxCompleteDecodeErrorZ() && { LDKCResult_TxCompleteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCompleteDecodeErrorZ)); return res; }
8751 ~CResult_TxCompleteDecodeErrorZ() { CResult_TxCompleteDecodeErrorZ_free(self); }
8752 CResult_TxCompleteDecodeErrorZ& operator=(CResult_TxCompleteDecodeErrorZ&& o) { CResult_TxCompleteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCompleteDecodeErrorZ)); return *this; }
8753 LDKCResult_TxCompleteDecodeErrorZ* operator &() { return &self; }
8754 LDKCResult_TxCompleteDecodeErrorZ* operator ->() { return &self; }
8755 const LDKCResult_TxCompleteDecodeErrorZ* operator &() const { return &self; }
8756 const LDKCResult_TxCompleteDecodeErrorZ* operator ->() const { return &self; }
8758 class CResult_UpdateFulfillHTLCDecodeErrorZ {
8760 LDKCResult_UpdateFulfillHTLCDecodeErrorZ self;
8762 CResult_UpdateFulfillHTLCDecodeErrorZ(const CResult_UpdateFulfillHTLCDecodeErrorZ&) = delete;
8763 CResult_UpdateFulfillHTLCDecodeErrorZ(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); }
8764 CResult_UpdateFulfillHTLCDecodeErrorZ(LDKCResult_UpdateFulfillHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); }
8765 operator LDKCResult_UpdateFulfillHTLCDecodeErrorZ() && { LDKCResult_UpdateFulfillHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ)); return res; }
8766 ~CResult_UpdateFulfillHTLCDecodeErrorZ() { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); }
8767 CResult_UpdateFulfillHTLCDecodeErrorZ& operator=(CResult_UpdateFulfillHTLCDecodeErrorZ&& o) { CResult_UpdateFulfillHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFulfillHTLCDecodeErrorZ)); return *this; }
8768 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() { return &self; }
8769 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() { return &self; }
8770 const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator &() const { return &self; }
8771 const LDKCResult_UpdateFulfillHTLCDecodeErrorZ* operator ->() const { return &self; }
8773 class CResult_NodeFeaturesDecodeErrorZ {
8775 LDKCResult_NodeFeaturesDecodeErrorZ self;
8777 CResult_NodeFeaturesDecodeErrorZ(const CResult_NodeFeaturesDecodeErrorZ&) = delete;
8778 CResult_NodeFeaturesDecodeErrorZ(CResult_NodeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); }
8779 CResult_NodeFeaturesDecodeErrorZ(LDKCResult_NodeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); }
8780 operator LDKCResult_NodeFeaturesDecodeErrorZ() && { LDKCResult_NodeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeFeaturesDecodeErrorZ)); return res; }
8781 ~CResult_NodeFeaturesDecodeErrorZ() { CResult_NodeFeaturesDecodeErrorZ_free(self); }
8782 CResult_NodeFeaturesDecodeErrorZ& operator=(CResult_NodeFeaturesDecodeErrorZ&& o) { CResult_NodeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeFeaturesDecodeErrorZ)); return *this; }
8783 LDKCResult_NodeFeaturesDecodeErrorZ* operator &() { return &self; }
8784 LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() { return &self; }
8785 const LDKCResult_NodeFeaturesDecodeErrorZ* operator &() const { return &self; }
8786 const LDKCResult_NodeFeaturesDecodeErrorZ* operator ->() const { return &self; }
8788 class CResult_InMemorySignerDecodeErrorZ {
8790 LDKCResult_InMemorySignerDecodeErrorZ self;
8792 CResult_InMemorySignerDecodeErrorZ(const CResult_InMemorySignerDecodeErrorZ&) = delete;
8793 CResult_InMemorySignerDecodeErrorZ(CResult_InMemorySignerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); }
8794 CResult_InMemorySignerDecodeErrorZ(LDKCResult_InMemorySignerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); }
8795 operator LDKCResult_InMemorySignerDecodeErrorZ() && { LDKCResult_InMemorySignerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InMemorySignerDecodeErrorZ)); return res; }
8796 ~CResult_InMemorySignerDecodeErrorZ() { CResult_InMemorySignerDecodeErrorZ_free(self); }
8797 CResult_InMemorySignerDecodeErrorZ& operator=(CResult_InMemorySignerDecodeErrorZ&& o) { CResult_InMemorySignerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InMemorySignerDecodeErrorZ)); return *this; }
8798 LDKCResult_InMemorySignerDecodeErrorZ* operator &() { return &self; }
8799 LDKCResult_InMemorySignerDecodeErrorZ* operator ->() { return &self; }
8800 const LDKCResult_InMemorySignerDecodeErrorZ* operator &() const { return &self; }
8801 const LDKCResult_InMemorySignerDecodeErrorZ* operator ->() const { return &self; }
8803 class CResult_TxSignaturesDecodeErrorZ {
8805 LDKCResult_TxSignaturesDecodeErrorZ self;
8807 CResult_TxSignaturesDecodeErrorZ(const CResult_TxSignaturesDecodeErrorZ&) = delete;
8808 CResult_TxSignaturesDecodeErrorZ(CResult_TxSignaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); }
8809 CResult_TxSignaturesDecodeErrorZ(LDKCResult_TxSignaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); }
8810 operator LDKCResult_TxSignaturesDecodeErrorZ() && { LDKCResult_TxSignaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxSignaturesDecodeErrorZ)); return res; }
8811 ~CResult_TxSignaturesDecodeErrorZ() { CResult_TxSignaturesDecodeErrorZ_free(self); }
8812 CResult_TxSignaturesDecodeErrorZ& operator=(CResult_TxSignaturesDecodeErrorZ&& o) { CResult_TxSignaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxSignaturesDecodeErrorZ)); return *this; }
8813 LDKCResult_TxSignaturesDecodeErrorZ* operator &() { return &self; }
8814 LDKCResult_TxSignaturesDecodeErrorZ* operator ->() { return &self; }
8815 const LDKCResult_TxSignaturesDecodeErrorZ* operator &() const { return &self; }
8816 const LDKCResult_TxSignaturesDecodeErrorZ* operator ->() const { return &self; }
8818 class CVec_HTLCDescriptorZ {
8820 LDKCVec_HTLCDescriptorZ self;
8822 CVec_HTLCDescriptorZ(const CVec_HTLCDescriptorZ&) = delete;
8823 CVec_HTLCDescriptorZ(CVec_HTLCDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); }
8824 CVec_HTLCDescriptorZ(LDKCVec_HTLCDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); }
8825 operator LDKCVec_HTLCDescriptorZ() && { LDKCVec_HTLCDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCDescriptorZ)); return res; }
8826 ~CVec_HTLCDescriptorZ() { CVec_HTLCDescriptorZ_free(self); }
8827 CVec_HTLCDescriptorZ& operator=(CVec_HTLCDescriptorZ&& o) { CVec_HTLCDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCDescriptorZ)); return *this; }
8828 LDKCVec_HTLCDescriptorZ* operator &() { return &self; }
8829 LDKCVec_HTLCDescriptorZ* operator ->() { return &self; }
8830 const LDKCVec_HTLCDescriptorZ* operator &() const { return &self; }
8831 const LDKCVec_HTLCDescriptorZ* operator ->() const { return &self; }
8833 class CResult_ReplyShortChannelIdsEndDecodeErrorZ {
8835 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ self;
8837 CResult_ReplyShortChannelIdsEndDecodeErrorZ(const CResult_ReplyShortChannelIdsEndDecodeErrorZ&) = delete;
8838 CResult_ReplyShortChannelIdsEndDecodeErrorZ(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8839 CResult_ReplyShortChannelIdsEndDecodeErrorZ(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); }
8840 operator LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ() && { LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ)); return res; }
8841 ~CResult_ReplyShortChannelIdsEndDecodeErrorZ() { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); }
8842 CResult_ReplyShortChannelIdsEndDecodeErrorZ& operator=(CResult_ReplyShortChannelIdsEndDecodeErrorZ&& o) { CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyShortChannelIdsEndDecodeErrorZ)); return *this; }
8843 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() { return &self; }
8844 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() { return &self; }
8845 const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator &() const { return &self; }
8846 const LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* operator ->() const { return &self; }
8848 class COption_PathFailureZ {
8850 LDKCOption_PathFailureZ self;
8852 COption_PathFailureZ(const COption_PathFailureZ&) = delete;
8853 COption_PathFailureZ(COption_PathFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PathFailureZ)); }
8854 COption_PathFailureZ(LDKCOption_PathFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PathFailureZ)); }
8855 operator LDKCOption_PathFailureZ() && { LDKCOption_PathFailureZ res = self; memset(&self, 0, sizeof(LDKCOption_PathFailureZ)); return res; }
8856 ~COption_PathFailureZ() { COption_PathFailureZ_free(self); }
8857 COption_PathFailureZ& operator=(COption_PathFailureZ&& o) { COption_PathFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PathFailureZ)); return *this; }
8858 LDKCOption_PathFailureZ* operator &() { return &self; }
8859 LDKCOption_PathFailureZ* operator ->() { return &self; }
8860 const LDKCOption_PathFailureZ* operator &() const { return &self; }
8861 const LDKCOption_PathFailureZ* operator ->() const { return &self; }
8863 class CResult_StrSecp256k1ErrorZ {
8865 LDKCResult_StrSecp256k1ErrorZ self;
8867 CResult_StrSecp256k1ErrorZ(const CResult_StrSecp256k1ErrorZ&) = delete;
8868 CResult_StrSecp256k1ErrorZ(CResult_StrSecp256k1ErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); }
8869 CResult_StrSecp256k1ErrorZ(LDKCResult_StrSecp256k1ErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); }
8870 operator LDKCResult_StrSecp256k1ErrorZ() && { LDKCResult_StrSecp256k1ErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_StrSecp256k1ErrorZ)); return res; }
8871 ~CResult_StrSecp256k1ErrorZ() { CResult_StrSecp256k1ErrorZ_free(self); }
8872 CResult_StrSecp256k1ErrorZ& operator=(CResult_StrSecp256k1ErrorZ&& o) { CResult_StrSecp256k1ErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_StrSecp256k1ErrorZ)); return *this; }
8873 LDKCResult_StrSecp256k1ErrorZ* operator &() { return &self; }
8874 LDKCResult_StrSecp256k1ErrorZ* operator ->() { return &self; }
8875 const LDKCResult_StrSecp256k1ErrorZ* operator &() const { return &self; }
8876 const LDKCResult_StrSecp256k1ErrorZ* operator ->() const { return &self; }
8878 class CVec_ECDSASignatureZ {
8880 LDKCVec_ECDSASignatureZ self;
8882 CVec_ECDSASignatureZ(const CVec_ECDSASignatureZ&) = delete;
8883 CVec_ECDSASignatureZ(CVec_ECDSASignatureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); }
8884 CVec_ECDSASignatureZ(LDKCVec_ECDSASignatureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ECDSASignatureZ)); }
8885 operator LDKCVec_ECDSASignatureZ() && { LDKCVec_ECDSASignatureZ res = self; memset(&self, 0, sizeof(LDKCVec_ECDSASignatureZ)); return res; }
8886 ~CVec_ECDSASignatureZ() { CVec_ECDSASignatureZ_free(self); }
8887 CVec_ECDSASignatureZ& operator=(CVec_ECDSASignatureZ&& o) { CVec_ECDSASignatureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ECDSASignatureZ)); return *this; }
8888 LDKCVec_ECDSASignatureZ* operator &() { return &self; }
8889 LDKCVec_ECDSASignatureZ* operator ->() { return &self; }
8890 const LDKCVec_ECDSASignatureZ* operator &() const { return &self; }
8891 const LDKCVec_ECDSASignatureZ* operator ->() const { return &self; }
8893 class CResult_ChannelUpdateInfoDecodeErrorZ {
8895 LDKCResult_ChannelUpdateInfoDecodeErrorZ self;
8897 CResult_ChannelUpdateInfoDecodeErrorZ(const CResult_ChannelUpdateInfoDecodeErrorZ&) = delete;
8898 CResult_ChannelUpdateInfoDecodeErrorZ(CResult_ChannelUpdateInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); }
8899 CResult_ChannelUpdateInfoDecodeErrorZ(LDKCResult_ChannelUpdateInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); }
8900 operator LDKCResult_ChannelUpdateInfoDecodeErrorZ() && { LDKCResult_ChannelUpdateInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ)); return res; }
8901 ~CResult_ChannelUpdateInfoDecodeErrorZ() { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); }
8902 CResult_ChannelUpdateInfoDecodeErrorZ& operator=(CResult_ChannelUpdateInfoDecodeErrorZ&& o) { CResult_ChannelUpdateInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateInfoDecodeErrorZ)); return *this; }
8903 LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() { return &self; }
8904 LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() { return &self; }
8905 const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator &() const { return &self; }
8906 const LDKCResult_ChannelUpdateInfoDecodeErrorZ* operator ->() const { return &self; }
8908 class CVec_UpdateFailHTLCZ {
8910 LDKCVec_UpdateFailHTLCZ self;
8912 CVec_UpdateFailHTLCZ(const CVec_UpdateFailHTLCZ&) = delete;
8913 CVec_UpdateFailHTLCZ(CVec_UpdateFailHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); }
8914 CVec_UpdateFailHTLCZ(LDKCVec_UpdateFailHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); }
8915 operator LDKCVec_UpdateFailHTLCZ() && { LDKCVec_UpdateFailHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_UpdateFailHTLCZ)); return res; }
8916 ~CVec_UpdateFailHTLCZ() { CVec_UpdateFailHTLCZ_free(self); }
8917 CVec_UpdateFailHTLCZ& operator=(CVec_UpdateFailHTLCZ&& o) { CVec_UpdateFailHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UpdateFailHTLCZ)); return *this; }
8918 LDKCVec_UpdateFailHTLCZ* operator &() { return &self; }
8919 LDKCVec_UpdateFailHTLCZ* operator ->() { return &self; }
8920 const LDKCVec_UpdateFailHTLCZ* operator &() const { return &self; }
8921 const LDKCVec_UpdateFailHTLCZ* operator ->() const { return &self; }
8925 LDKCVec_TxOutZ self;
8927 CVec_TxOutZ(const CVec_TxOutZ&) = delete;
8928 CVec_TxOutZ(CVec_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TxOutZ)); }
8929 CVec_TxOutZ(LDKCVec_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TxOutZ)); }
8930 operator LDKCVec_TxOutZ() && { LDKCVec_TxOutZ res = self; memset(&self, 0, sizeof(LDKCVec_TxOutZ)); return res; }
8931 ~CVec_TxOutZ() { CVec_TxOutZ_free(self); }
8932 CVec_TxOutZ& operator=(CVec_TxOutZ&& o) { CVec_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TxOutZ)); return *this; }
8933 LDKCVec_TxOutZ* operator &() { return &self; }
8934 LDKCVec_TxOutZ* operator ->() { return &self; }
8935 const LDKCVec_TxOutZ* operator &() const { return &self; }
8936 const LDKCVec_TxOutZ* operator ->() const { return &self; }
8938 class CResult_BuiltCommitmentTransactionDecodeErrorZ {
8940 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ self;
8942 CResult_BuiltCommitmentTransactionDecodeErrorZ(const CResult_BuiltCommitmentTransactionDecodeErrorZ&) = delete;
8943 CResult_BuiltCommitmentTransactionDecodeErrorZ(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8944 CResult_BuiltCommitmentTransactionDecodeErrorZ(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); }
8945 operator LDKCResult_BuiltCommitmentTransactionDecodeErrorZ() && { LDKCResult_BuiltCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ)); return res; }
8946 ~CResult_BuiltCommitmentTransactionDecodeErrorZ() { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); }
8947 CResult_BuiltCommitmentTransactionDecodeErrorZ& operator=(CResult_BuiltCommitmentTransactionDecodeErrorZ&& o) { CResult_BuiltCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BuiltCommitmentTransactionDecodeErrorZ)); return *this; }
8948 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
8949 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
8950 const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
8951 const LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
8953 class CVec_SpendableOutputDescriptorZ {
8955 LDKCVec_SpendableOutputDescriptorZ self;
8957 CVec_SpendableOutputDescriptorZ(const CVec_SpendableOutputDescriptorZ&) = delete;
8958 CVec_SpendableOutputDescriptorZ(CVec_SpendableOutputDescriptorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); }
8959 CVec_SpendableOutputDescriptorZ(LDKCVec_SpendableOutputDescriptorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); }
8960 operator LDKCVec_SpendableOutputDescriptorZ() && { LDKCVec_SpendableOutputDescriptorZ res = self; memset(&self, 0, sizeof(LDKCVec_SpendableOutputDescriptorZ)); return res; }
8961 ~CVec_SpendableOutputDescriptorZ() { CVec_SpendableOutputDescriptorZ_free(self); }
8962 CVec_SpendableOutputDescriptorZ& operator=(CVec_SpendableOutputDescriptorZ&& o) { CVec_SpendableOutputDescriptorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SpendableOutputDescriptorZ)); return *this; }
8963 LDKCVec_SpendableOutputDescriptorZ* operator &() { return &self; }
8964 LDKCVec_SpendableOutputDescriptorZ* operator ->() { return &self; }
8965 const LDKCVec_SpendableOutputDescriptorZ* operator &() const { return &self; }
8966 const LDKCVec_SpendableOutputDescriptorZ* operator ->() const { return &self; }
8968 class C2Tuple_OutPointCVec_u8ZZ {
8970 LDKC2Tuple_OutPointCVec_u8ZZ self;
8972 C2Tuple_OutPointCVec_u8ZZ(const C2Tuple_OutPointCVec_u8ZZ&) = delete;
8973 C2Tuple_OutPointCVec_u8ZZ(C2Tuple_OutPointCVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_OutPointCVec_u8ZZ)); }
8974 C2Tuple_OutPointCVec_u8ZZ(LDKC2Tuple_OutPointCVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); }
8975 operator LDKC2Tuple_OutPointCVec_u8ZZ() && { LDKC2Tuple_OutPointCVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_OutPointCVec_u8ZZ)); return res; }
8976 ~C2Tuple_OutPointCVec_u8ZZ() { C2Tuple_OutPointCVec_u8ZZ_free(self); }
8977 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; }
8978 LDKC2Tuple_OutPointCVec_u8ZZ* operator &() { return &self; }
8979 LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() { return &self; }
8980 const LDKC2Tuple_OutPointCVec_u8ZZ* operator &() const { return &self; }
8981 const LDKC2Tuple_OutPointCVec_u8ZZ* operator ->() const { return &self; }
8983 class CResult_WitnessNoneZ {
8985 LDKCResult_WitnessNoneZ self;
8987 CResult_WitnessNoneZ(const CResult_WitnessNoneZ&) = delete;
8988 CResult_WitnessNoneZ(CResult_WitnessNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WitnessNoneZ)); }
8989 CResult_WitnessNoneZ(LDKCResult_WitnessNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WitnessNoneZ)); }
8990 operator LDKCResult_WitnessNoneZ() && { LDKCResult_WitnessNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_WitnessNoneZ)); return res; }
8991 ~CResult_WitnessNoneZ() { CResult_WitnessNoneZ_free(self); }
8992 CResult_WitnessNoneZ& operator=(CResult_WitnessNoneZ&& o) { CResult_WitnessNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WitnessNoneZ)); return *this; }
8993 LDKCResult_WitnessNoneZ* operator &() { return &self; }
8994 LDKCResult_WitnessNoneZ* operator ->() { return &self; }
8995 const LDKCResult_WitnessNoneZ* operator &() const { return &self; }
8996 const LDKCResult_WitnessNoneZ* operator ->() const { return &self; }
8998 class COption_C2Tuple_u64u64ZZ {
9000 LDKCOption_C2Tuple_u64u64ZZ self;
9002 COption_C2Tuple_u64u64ZZ(const COption_C2Tuple_u64u64ZZ&) = delete;
9003 COption_C2Tuple_u64u64ZZ(COption_C2Tuple_u64u64ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u64ZZ)); }
9004 COption_C2Tuple_u64u64ZZ(LDKCOption_C2Tuple_u64u64ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); }
9005 operator LDKCOption_C2Tuple_u64u64ZZ() && { LDKCOption_C2Tuple_u64u64ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u64ZZ)); return res; }
9006 ~COption_C2Tuple_u64u64ZZ() { COption_C2Tuple_u64u64ZZ_free(self); }
9007 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; }
9008 LDKCOption_C2Tuple_u64u64ZZ* operator &() { return &self; }
9009 LDKCOption_C2Tuple_u64u64ZZ* operator ->() { return &self; }
9010 const LDKCOption_C2Tuple_u64u64ZZ* operator &() const { return &self; }
9011 const LDKCOption_C2Tuple_u64u64ZZ* operator ->() const { return &self; }
9013 class CResult_ChannelAnnouncementDecodeErrorZ {
9015 LDKCResult_ChannelAnnouncementDecodeErrorZ self;
9017 CResult_ChannelAnnouncementDecodeErrorZ(const CResult_ChannelAnnouncementDecodeErrorZ&) = delete;
9018 CResult_ChannelAnnouncementDecodeErrorZ(CResult_ChannelAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); }
9019 CResult_ChannelAnnouncementDecodeErrorZ(LDKCResult_ChannelAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); }
9020 operator LDKCResult_ChannelAnnouncementDecodeErrorZ() && { LDKCResult_ChannelAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ)); return res; }
9021 ~CResult_ChannelAnnouncementDecodeErrorZ() { CResult_ChannelAnnouncementDecodeErrorZ_free(self); }
9022 CResult_ChannelAnnouncementDecodeErrorZ& operator=(CResult_ChannelAnnouncementDecodeErrorZ&& o) { CResult_ChannelAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelAnnouncementDecodeErrorZ)); return *this; }
9023 LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() { return &self; }
9024 LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() { return &self; }
9025 const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator &() const { return &self; }
9026 const LDKCResult_ChannelAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9028 class CResult_HTLCUpdateDecodeErrorZ {
9030 LDKCResult_HTLCUpdateDecodeErrorZ self;
9032 CResult_HTLCUpdateDecodeErrorZ(const CResult_HTLCUpdateDecodeErrorZ&) = delete;
9033 CResult_HTLCUpdateDecodeErrorZ(CResult_HTLCUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); }
9034 CResult_HTLCUpdateDecodeErrorZ(LDKCResult_HTLCUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); }
9035 operator LDKCResult_HTLCUpdateDecodeErrorZ() && { LDKCResult_HTLCUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HTLCUpdateDecodeErrorZ)); return res; }
9036 ~CResult_HTLCUpdateDecodeErrorZ() { CResult_HTLCUpdateDecodeErrorZ_free(self); }
9037 CResult_HTLCUpdateDecodeErrorZ& operator=(CResult_HTLCUpdateDecodeErrorZ&& o) { CResult_HTLCUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HTLCUpdateDecodeErrorZ)); return *this; }
9038 LDKCResult_HTLCUpdateDecodeErrorZ* operator &() { return &self; }
9039 LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() { return &self; }
9040 const LDKCResult_HTLCUpdateDecodeErrorZ* operator &() const { return &self; }
9041 const LDKCResult_HTLCUpdateDecodeErrorZ* operator ->() const { return &self; }
9043 class CResult_TxAddInputDecodeErrorZ {
9045 LDKCResult_TxAddInputDecodeErrorZ self;
9047 CResult_TxAddInputDecodeErrorZ(const CResult_TxAddInputDecodeErrorZ&) = delete;
9048 CResult_TxAddInputDecodeErrorZ(CResult_TxAddInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); }
9049 CResult_TxAddInputDecodeErrorZ(LDKCResult_TxAddInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); }
9050 operator LDKCResult_TxAddInputDecodeErrorZ() && { LDKCResult_TxAddInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddInputDecodeErrorZ)); return res; }
9051 ~CResult_TxAddInputDecodeErrorZ() { CResult_TxAddInputDecodeErrorZ_free(self); }
9052 CResult_TxAddInputDecodeErrorZ& operator=(CResult_TxAddInputDecodeErrorZ&& o) { CResult_TxAddInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddInputDecodeErrorZ)); return *this; }
9053 LDKCResult_TxAddInputDecodeErrorZ* operator &() { return &self; }
9054 LDKCResult_TxAddInputDecodeErrorZ* operator ->() { return &self; }
9055 const LDKCResult_TxAddInputDecodeErrorZ* operator &() const { return &self; }
9056 const LDKCResult_TxAddInputDecodeErrorZ* operator ->() const { return &self; }
9058 class CResult_PeeledOnionNoneZ {
9060 LDKCResult_PeeledOnionNoneZ self;
9062 CResult_PeeledOnionNoneZ(const CResult_PeeledOnionNoneZ&) = delete;
9063 CResult_PeeledOnionNoneZ(CResult_PeeledOnionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); }
9064 CResult_PeeledOnionNoneZ(LDKCResult_PeeledOnionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); }
9065 operator LDKCResult_PeeledOnionNoneZ() && { LDKCResult_PeeledOnionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PeeledOnionNoneZ)); return res; }
9066 ~CResult_PeeledOnionNoneZ() { CResult_PeeledOnionNoneZ_free(self); }
9067 CResult_PeeledOnionNoneZ& operator=(CResult_PeeledOnionNoneZ&& o) { CResult_PeeledOnionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PeeledOnionNoneZ)); return *this; }
9068 LDKCResult_PeeledOnionNoneZ* operator &() { return &self; }
9069 LDKCResult_PeeledOnionNoneZ* operator ->() { return &self; }
9070 const LDKCResult_PeeledOnionNoneZ* operator &() const { return &self; }
9071 const LDKCResult_PeeledOnionNoneZ* operator ->() const { return &self; }
9073 class CResult_TxInitRbfDecodeErrorZ {
9075 LDKCResult_TxInitRbfDecodeErrorZ self;
9077 CResult_TxInitRbfDecodeErrorZ(const CResult_TxInitRbfDecodeErrorZ&) = delete;
9078 CResult_TxInitRbfDecodeErrorZ(CResult_TxInitRbfDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); }
9079 CResult_TxInitRbfDecodeErrorZ(LDKCResult_TxInitRbfDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); }
9080 operator LDKCResult_TxInitRbfDecodeErrorZ() && { LDKCResult_TxInitRbfDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxInitRbfDecodeErrorZ)); return res; }
9081 ~CResult_TxInitRbfDecodeErrorZ() { CResult_TxInitRbfDecodeErrorZ_free(self); }
9082 CResult_TxInitRbfDecodeErrorZ& operator=(CResult_TxInitRbfDecodeErrorZ&& o) { CResult_TxInitRbfDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxInitRbfDecodeErrorZ)); return *this; }
9083 LDKCResult_TxInitRbfDecodeErrorZ* operator &() { return &self; }
9084 LDKCResult_TxInitRbfDecodeErrorZ* operator ->() { return &self; }
9085 const LDKCResult_TxInitRbfDecodeErrorZ* operator &() const { return &self; }
9086 const LDKCResult_TxInitRbfDecodeErrorZ* operator ->() const { return &self; }
9088 class COption_WriteableScoreZ {
9090 LDKCOption_WriteableScoreZ self;
9092 COption_WriteableScoreZ(const COption_WriteableScoreZ&) = delete;
9093 COption_WriteableScoreZ(COption_WriteableScoreZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_WriteableScoreZ)); }
9094 COption_WriteableScoreZ(LDKCOption_WriteableScoreZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_WriteableScoreZ)); }
9095 operator LDKCOption_WriteableScoreZ() && { LDKCOption_WriteableScoreZ res = self; memset(&self, 0, sizeof(LDKCOption_WriteableScoreZ)); return res; }
9096 ~COption_WriteableScoreZ() { COption_WriteableScoreZ_free(self); }
9097 COption_WriteableScoreZ& operator=(COption_WriteableScoreZ&& o) { COption_WriteableScoreZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_WriteableScoreZ)); return *this; }
9098 LDKCOption_WriteableScoreZ* operator &() { return &self; }
9099 LDKCOption_WriteableScoreZ* operator ->() { return &self; }
9100 const LDKCOption_WriteableScoreZ* operator &() const { return &self; }
9101 const LDKCOption_WriteableScoreZ* operator ->() const { return &self; }
9107 CVec_StrZ(const CVec_StrZ&) = delete;
9108 CVec_StrZ(CVec_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_StrZ)); }
9109 CVec_StrZ(LDKCVec_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_StrZ)); }
9110 operator LDKCVec_StrZ() && { LDKCVec_StrZ res = self; memset(&self, 0, sizeof(LDKCVec_StrZ)); return res; }
9111 ~CVec_StrZ() { CVec_StrZ_free(self); }
9112 CVec_StrZ& operator=(CVec_StrZ&& o) { CVec_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_StrZ)); return *this; }
9113 LDKCVec_StrZ* operator &() { return &self; }
9114 LDKCVec_StrZ* operator ->() { return &self; }
9115 const LDKCVec_StrZ* operator &() const { return &self; }
9116 const LDKCVec_StrZ* operator ->() const { return &self; }
9118 class CVec_OutPointZ {
9120 LDKCVec_OutPointZ self;
9122 CVec_OutPointZ(const CVec_OutPointZ&) = delete;
9123 CVec_OutPointZ(CVec_OutPointZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_OutPointZ)); }
9124 CVec_OutPointZ(LDKCVec_OutPointZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_OutPointZ)); }
9125 operator LDKCVec_OutPointZ() && { LDKCVec_OutPointZ res = self; memset(&self, 0, sizeof(LDKCVec_OutPointZ)); return res; }
9126 ~CVec_OutPointZ() { CVec_OutPointZ_free(self); }
9127 CVec_OutPointZ& operator=(CVec_OutPointZ&& o) { CVec_OutPointZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_OutPointZ)); return *this; }
9128 LDKCVec_OutPointZ* operator &() { return &self; }
9129 LDKCVec_OutPointZ* operator ->() { return &self; }
9130 const LDKCVec_OutPointZ* operator &() const { return &self; }
9131 const LDKCVec_OutPointZ* operator ->() const { return &self; }
9133 class CResult_SpliceAckDecodeErrorZ {
9135 LDKCResult_SpliceAckDecodeErrorZ self;
9137 CResult_SpliceAckDecodeErrorZ(const CResult_SpliceAckDecodeErrorZ&) = delete;
9138 CResult_SpliceAckDecodeErrorZ(CResult_SpliceAckDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); }
9139 CResult_SpliceAckDecodeErrorZ(LDKCResult_SpliceAckDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); }
9140 operator LDKCResult_SpliceAckDecodeErrorZ() && { LDKCResult_SpliceAckDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceAckDecodeErrorZ)); return res; }
9141 ~CResult_SpliceAckDecodeErrorZ() { CResult_SpliceAckDecodeErrorZ_free(self); }
9142 CResult_SpliceAckDecodeErrorZ& operator=(CResult_SpliceAckDecodeErrorZ&& o) { CResult_SpliceAckDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceAckDecodeErrorZ)); return *this; }
9143 LDKCResult_SpliceAckDecodeErrorZ* operator &() { return &self; }
9144 LDKCResult_SpliceAckDecodeErrorZ* operator ->() { return &self; }
9145 const LDKCResult_SpliceAckDecodeErrorZ* operator &() const { return &self; }
9146 const LDKCResult_SpliceAckDecodeErrorZ* operator ->() const { return &self; }
9148 class CResult_PositiveTimestampCreationErrorZ {
9150 LDKCResult_PositiveTimestampCreationErrorZ self;
9152 CResult_PositiveTimestampCreationErrorZ(const CResult_PositiveTimestampCreationErrorZ&) = delete;
9153 CResult_PositiveTimestampCreationErrorZ(CResult_PositiveTimestampCreationErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); }
9154 CResult_PositiveTimestampCreationErrorZ(LDKCResult_PositiveTimestampCreationErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); }
9155 operator LDKCResult_PositiveTimestampCreationErrorZ() && { LDKCResult_PositiveTimestampCreationErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PositiveTimestampCreationErrorZ)); return res; }
9156 ~CResult_PositiveTimestampCreationErrorZ() { CResult_PositiveTimestampCreationErrorZ_free(self); }
9157 CResult_PositiveTimestampCreationErrorZ& operator=(CResult_PositiveTimestampCreationErrorZ&& o) { CResult_PositiveTimestampCreationErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PositiveTimestampCreationErrorZ)); return *this; }
9158 LDKCResult_PositiveTimestampCreationErrorZ* operator &() { return &self; }
9159 LDKCResult_PositiveTimestampCreationErrorZ* operator ->() { return &self; }
9160 const LDKCResult_PositiveTimestampCreationErrorZ* operator &() const { return &self; }
9161 const LDKCResult_PositiveTimestampCreationErrorZ* operator ->() const { return &self; }
9163 class CResult_ChannelMonitorUpdateDecodeErrorZ {
9165 LDKCResult_ChannelMonitorUpdateDecodeErrorZ self;
9167 CResult_ChannelMonitorUpdateDecodeErrorZ(const CResult_ChannelMonitorUpdateDecodeErrorZ&) = delete;
9168 CResult_ChannelMonitorUpdateDecodeErrorZ(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); }
9169 CResult_ChannelMonitorUpdateDecodeErrorZ(LDKCResult_ChannelMonitorUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); }
9170 operator LDKCResult_ChannelMonitorUpdateDecodeErrorZ() && { LDKCResult_ChannelMonitorUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ)); return res; }
9171 ~CResult_ChannelMonitorUpdateDecodeErrorZ() { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); }
9172 CResult_ChannelMonitorUpdateDecodeErrorZ& operator=(CResult_ChannelMonitorUpdateDecodeErrorZ&& o) { CResult_ChannelMonitorUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelMonitorUpdateDecodeErrorZ)); return *this; }
9173 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() { return &self; }
9174 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() { return &self; }
9175 const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator &() const { return &self; }
9176 const LDKCResult_ChannelMonitorUpdateDecodeErrorZ* operator ->() const { return &self; }
9178 class C2Tuple_BlindedPayInfoBlindedPathZ {
9180 LDKC2Tuple_BlindedPayInfoBlindedPathZ self;
9182 C2Tuple_BlindedPayInfoBlindedPathZ(const C2Tuple_BlindedPayInfoBlindedPathZ&) = delete;
9183 C2Tuple_BlindedPayInfoBlindedPathZ(C2Tuple_BlindedPayInfoBlindedPathZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); }
9184 C2Tuple_BlindedPayInfoBlindedPathZ(LDKC2Tuple_BlindedPayInfoBlindedPathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); }
9185 operator LDKC2Tuple_BlindedPayInfoBlindedPathZ() && { LDKC2Tuple_BlindedPayInfoBlindedPathZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ)); return res; }
9186 ~C2Tuple_BlindedPayInfoBlindedPathZ() { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); }
9187 C2Tuple_BlindedPayInfoBlindedPathZ& operator=(C2Tuple_BlindedPayInfoBlindedPathZ&& o) { C2Tuple_BlindedPayInfoBlindedPathZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_BlindedPayInfoBlindedPathZ)); return *this; }
9188 LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() { return &self; }
9189 LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() { return &self; }
9190 const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator &() const { return &self; }
9191 const LDKC2Tuple_BlindedPayInfoBlindedPathZ* operator ->() const { return &self; }
9193 class CResult_ReplyChannelRangeDecodeErrorZ {
9195 LDKCResult_ReplyChannelRangeDecodeErrorZ self;
9197 CResult_ReplyChannelRangeDecodeErrorZ(const CResult_ReplyChannelRangeDecodeErrorZ&) = delete;
9198 CResult_ReplyChannelRangeDecodeErrorZ(CResult_ReplyChannelRangeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); }
9199 CResult_ReplyChannelRangeDecodeErrorZ(LDKCResult_ReplyChannelRangeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); }
9200 operator LDKCResult_ReplyChannelRangeDecodeErrorZ() && { LDKCResult_ReplyChannelRangeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ)); return res; }
9201 ~CResult_ReplyChannelRangeDecodeErrorZ() { CResult_ReplyChannelRangeDecodeErrorZ_free(self); }
9202 CResult_ReplyChannelRangeDecodeErrorZ& operator=(CResult_ReplyChannelRangeDecodeErrorZ&& o) { CResult_ReplyChannelRangeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ReplyChannelRangeDecodeErrorZ)); return *this; }
9203 LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() { return &self; }
9204 LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() { return &self; }
9205 const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator &() const { return &self; }
9206 const LDKCResult_ReplyChannelRangeDecodeErrorZ* operator ->() const { return &self; }
9208 class CResult_UnsignedNodeAnnouncementDecodeErrorZ {
9210 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ self;
9212 CResult_UnsignedNodeAnnouncementDecodeErrorZ(const CResult_UnsignedNodeAnnouncementDecodeErrorZ&) = delete;
9213 CResult_UnsignedNodeAnnouncementDecodeErrorZ(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
9214 CResult_UnsignedNodeAnnouncementDecodeErrorZ(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); }
9215 operator LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ() && { LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ)); return res; }
9216 ~CResult_UnsignedNodeAnnouncementDecodeErrorZ() { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); }
9217 CResult_UnsignedNodeAnnouncementDecodeErrorZ& operator=(CResult_UnsignedNodeAnnouncementDecodeErrorZ&& o) { CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UnsignedNodeAnnouncementDecodeErrorZ)); return *this; }
9218 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() { return &self; }
9219 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
9220 const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
9221 const LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9223 class CResult_TrustedClosingTransactionNoneZ {
9225 LDKCResult_TrustedClosingTransactionNoneZ self;
9227 CResult_TrustedClosingTransactionNoneZ(const CResult_TrustedClosingTransactionNoneZ&) = delete;
9228 CResult_TrustedClosingTransactionNoneZ(CResult_TrustedClosingTransactionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); }
9229 CResult_TrustedClosingTransactionNoneZ(LDKCResult_TrustedClosingTransactionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); }
9230 operator LDKCResult_TrustedClosingTransactionNoneZ() && { LDKCResult_TrustedClosingTransactionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_TrustedClosingTransactionNoneZ)); return res; }
9231 ~CResult_TrustedClosingTransactionNoneZ() { CResult_TrustedClosingTransactionNoneZ_free(self); }
9232 CResult_TrustedClosingTransactionNoneZ& operator=(CResult_TrustedClosingTransactionNoneZ&& o) { CResult_TrustedClosingTransactionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TrustedClosingTransactionNoneZ)); return *this; }
9233 LDKCResult_TrustedClosingTransactionNoneZ* operator &() { return &self; }
9234 LDKCResult_TrustedClosingTransactionNoneZ* operator ->() { return &self; }
9235 const LDKCResult_TrustedClosingTransactionNoneZ* operator &() const { return &self; }
9236 const LDKCResult_TrustedClosingTransactionNoneZ* operator ->() const { return &self; }
9238 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ {
9240 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ self;
9242 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&) = delete;
9243 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
9244 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); }
9245 operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ)); return res; }
9246 ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(self); }
9247 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; }
9248 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() { return &self; }
9249 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() { return &self; }
9250 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator &() const { return &self; }
9251 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* operator ->() const { return &self; }
9253 class C2Tuple_PublicKeyTypeZ {
9255 LDKC2Tuple_PublicKeyTypeZ self;
9257 C2Tuple_PublicKeyTypeZ(const C2Tuple_PublicKeyTypeZ&) = delete;
9258 C2Tuple_PublicKeyTypeZ(C2Tuple_PublicKeyTypeZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); }
9259 C2Tuple_PublicKeyTypeZ(LDKC2Tuple_PublicKeyTypeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); }
9260 operator LDKC2Tuple_PublicKeyTypeZ() && { LDKC2Tuple_PublicKeyTypeZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_PublicKeyTypeZ)); return res; }
9261 ~C2Tuple_PublicKeyTypeZ() { C2Tuple_PublicKeyTypeZ_free(self); }
9262 C2Tuple_PublicKeyTypeZ& operator=(C2Tuple_PublicKeyTypeZ&& o) { C2Tuple_PublicKeyTypeZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_PublicKeyTypeZ)); return *this; }
9263 LDKC2Tuple_PublicKeyTypeZ* operator &() { return &self; }
9264 LDKC2Tuple_PublicKeyTypeZ* operator ->() { return &self; }
9265 const LDKC2Tuple_PublicKeyTypeZ* operator &() const { return &self; }
9266 const LDKC2Tuple_PublicKeyTypeZ* operator ->() const { return &self; }
9268 class CResult_TxRemoveOutputDecodeErrorZ {
9270 LDKCResult_TxRemoveOutputDecodeErrorZ self;
9272 CResult_TxRemoveOutputDecodeErrorZ(const CResult_TxRemoveOutputDecodeErrorZ&) = delete;
9273 CResult_TxRemoveOutputDecodeErrorZ(CResult_TxRemoveOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); }
9274 CResult_TxRemoveOutputDecodeErrorZ(LDKCResult_TxRemoveOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); }
9275 operator LDKCResult_TxRemoveOutputDecodeErrorZ() && { LDKCResult_TxRemoveOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ)); return res; }
9276 ~CResult_TxRemoveOutputDecodeErrorZ() { CResult_TxRemoveOutputDecodeErrorZ_free(self); }
9277 CResult_TxRemoveOutputDecodeErrorZ& operator=(CResult_TxRemoveOutputDecodeErrorZ&& o) { CResult_TxRemoveOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveOutputDecodeErrorZ)); return *this; }
9278 LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() { return &self; }
9279 LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() { return &self; }
9280 const LDKCResult_TxRemoveOutputDecodeErrorZ* operator &() const { return &self; }
9281 const LDKCResult_TxRemoveOutputDecodeErrorZ* operator ->() const { return &self; }
9283 class CResult_ChannelReestablishDecodeErrorZ {
9285 LDKCResult_ChannelReestablishDecodeErrorZ self;
9287 CResult_ChannelReestablishDecodeErrorZ(const CResult_ChannelReestablishDecodeErrorZ&) = delete;
9288 CResult_ChannelReestablishDecodeErrorZ(CResult_ChannelReestablishDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); }
9289 CResult_ChannelReestablishDecodeErrorZ(LDKCResult_ChannelReestablishDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); }
9290 operator LDKCResult_ChannelReestablishDecodeErrorZ() && { LDKCResult_ChannelReestablishDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelReestablishDecodeErrorZ)); return res; }
9291 ~CResult_ChannelReestablishDecodeErrorZ() { CResult_ChannelReestablishDecodeErrorZ_free(self); }
9292 CResult_ChannelReestablishDecodeErrorZ& operator=(CResult_ChannelReestablishDecodeErrorZ&& o) { CResult_ChannelReestablishDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelReestablishDecodeErrorZ)); return *this; }
9293 LDKCResult_ChannelReestablishDecodeErrorZ* operator &() { return &self; }
9294 LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() { return &self; }
9295 const LDKCResult_ChannelReestablishDecodeErrorZ* operator &() const { return &self; }
9296 const LDKCResult_ChannelReestablishDecodeErrorZ* operator ->() const { return &self; }
9298 class CResult_OnionMessageDecodeErrorZ {
9300 LDKCResult_OnionMessageDecodeErrorZ self;
9302 CResult_OnionMessageDecodeErrorZ(const CResult_OnionMessageDecodeErrorZ&) = delete;
9303 CResult_OnionMessageDecodeErrorZ(CResult_OnionMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); }
9304 CResult_OnionMessageDecodeErrorZ(LDKCResult_OnionMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); }
9305 operator LDKCResult_OnionMessageDecodeErrorZ() && { LDKCResult_OnionMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessageDecodeErrorZ)); return res; }
9306 ~CResult_OnionMessageDecodeErrorZ() { CResult_OnionMessageDecodeErrorZ_free(self); }
9307 CResult_OnionMessageDecodeErrorZ& operator=(CResult_OnionMessageDecodeErrorZ&& o) { CResult_OnionMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessageDecodeErrorZ)); return *this; }
9308 LDKCResult_OnionMessageDecodeErrorZ* operator &() { return &self; }
9309 LDKCResult_OnionMessageDecodeErrorZ* operator ->() { return &self; }
9310 const LDKCResult_OnionMessageDecodeErrorZ* operator &() const { return &self; }
9311 const LDKCResult_OnionMessageDecodeErrorZ* operator ->() const { return &self; }
9313 class CResult_Bolt11InvoiceParseOrSemanticErrorZ {
9315 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ self;
9317 CResult_Bolt11InvoiceParseOrSemanticErrorZ(const CResult_Bolt11InvoiceParseOrSemanticErrorZ&) = delete;
9318 CResult_Bolt11InvoiceParseOrSemanticErrorZ(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
9319 CResult_Bolt11InvoiceParseOrSemanticErrorZ(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); }
9320 operator LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ() && { LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ)); return res; }
9321 ~CResult_Bolt11InvoiceParseOrSemanticErrorZ() { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); }
9322 CResult_Bolt11InvoiceParseOrSemanticErrorZ& operator=(CResult_Bolt11InvoiceParseOrSemanticErrorZ&& o) { CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceParseOrSemanticErrorZ)); return *this; }
9323 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() { return &self; }
9324 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() { return &self; }
9325 const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator &() const { return &self; }
9326 const LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* operator ->() const { return &self; }
9328 class CResult_InitFeaturesDecodeErrorZ {
9330 LDKCResult_InitFeaturesDecodeErrorZ self;
9332 CResult_InitFeaturesDecodeErrorZ(const CResult_InitFeaturesDecodeErrorZ&) = delete;
9333 CResult_InitFeaturesDecodeErrorZ(CResult_InitFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); }
9334 CResult_InitFeaturesDecodeErrorZ(LDKCResult_InitFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); }
9335 operator LDKCResult_InitFeaturesDecodeErrorZ() && { LDKCResult_InitFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitFeaturesDecodeErrorZ)); return res; }
9336 ~CResult_InitFeaturesDecodeErrorZ() { CResult_InitFeaturesDecodeErrorZ_free(self); }
9337 CResult_InitFeaturesDecodeErrorZ& operator=(CResult_InitFeaturesDecodeErrorZ&& o) { CResult_InitFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitFeaturesDecodeErrorZ)); return *this; }
9338 LDKCResult_InitFeaturesDecodeErrorZ* operator &() { return &self; }
9339 LDKCResult_InitFeaturesDecodeErrorZ* operator ->() { return &self; }
9340 const LDKCResult_InitFeaturesDecodeErrorZ* operator &() const { return &self; }
9341 const LDKCResult_InitFeaturesDecodeErrorZ* operator ->() const { return &self; }
9343 class CResult_PublicKeyNoneZ {
9345 LDKCResult_PublicKeyNoneZ self;
9347 CResult_PublicKeyNoneZ(const CResult_PublicKeyNoneZ&) = delete;
9348 CResult_PublicKeyNoneZ(CResult_PublicKeyNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); }
9349 CResult_PublicKeyNoneZ(LDKCResult_PublicKeyNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); }
9350 operator LDKCResult_PublicKeyNoneZ() && { LDKCResult_PublicKeyNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_PublicKeyNoneZ)); return res; }
9351 ~CResult_PublicKeyNoneZ() { CResult_PublicKeyNoneZ_free(self); }
9352 CResult_PublicKeyNoneZ& operator=(CResult_PublicKeyNoneZ&& o) { CResult_PublicKeyNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PublicKeyNoneZ)); return *this; }
9353 LDKCResult_PublicKeyNoneZ* operator &() { return &self; }
9354 LDKCResult_PublicKeyNoneZ* operator ->() { return &self; }
9355 const LDKCResult_PublicKeyNoneZ* operator &() const { return &self; }
9356 const LDKCResult_PublicKeyNoneZ* operator ->() const { return &self; }
9358 class CResult_PingDecodeErrorZ {
9360 LDKCResult_PingDecodeErrorZ self;
9362 CResult_PingDecodeErrorZ(const CResult_PingDecodeErrorZ&) = delete;
9363 CResult_PingDecodeErrorZ(CResult_PingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); }
9364 CResult_PingDecodeErrorZ(LDKCResult_PingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); }
9365 operator LDKCResult_PingDecodeErrorZ() && { LDKCResult_PingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PingDecodeErrorZ)); return res; }
9366 ~CResult_PingDecodeErrorZ() { CResult_PingDecodeErrorZ_free(self); }
9367 CResult_PingDecodeErrorZ& operator=(CResult_PingDecodeErrorZ&& o) { CResult_PingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PingDecodeErrorZ)); return *this; }
9368 LDKCResult_PingDecodeErrorZ* operator &() { return &self; }
9369 LDKCResult_PingDecodeErrorZ* operator ->() { return &self; }
9370 const LDKCResult_PingDecodeErrorZ* operator &() const { return &self; }
9371 const LDKCResult_PingDecodeErrorZ* operator ->() const { return &self; }
9373 class CResult_RevocationKeyDecodeErrorZ {
9375 LDKCResult_RevocationKeyDecodeErrorZ self;
9377 CResult_RevocationKeyDecodeErrorZ(const CResult_RevocationKeyDecodeErrorZ&) = delete;
9378 CResult_RevocationKeyDecodeErrorZ(CResult_RevocationKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); }
9379 CResult_RevocationKeyDecodeErrorZ(LDKCResult_RevocationKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); }
9380 operator LDKCResult_RevocationKeyDecodeErrorZ() && { LDKCResult_RevocationKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RevocationKeyDecodeErrorZ)); return res; }
9381 ~CResult_RevocationKeyDecodeErrorZ() { CResult_RevocationKeyDecodeErrorZ_free(self); }
9382 CResult_RevocationKeyDecodeErrorZ& operator=(CResult_RevocationKeyDecodeErrorZ&& o) { CResult_RevocationKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RevocationKeyDecodeErrorZ)); return *this; }
9383 LDKCResult_RevocationKeyDecodeErrorZ* operator &() { return &self; }
9384 LDKCResult_RevocationKeyDecodeErrorZ* operator ->() { return &self; }
9385 const LDKCResult_RevocationKeyDecodeErrorZ* operator &() const { return &self; }
9386 const LDKCResult_RevocationKeyDecodeErrorZ* operator ->() const { return &self; }
9388 class CResult_BlindedHopFeaturesDecodeErrorZ {
9390 LDKCResult_BlindedHopFeaturesDecodeErrorZ self;
9392 CResult_BlindedHopFeaturesDecodeErrorZ(const CResult_BlindedHopFeaturesDecodeErrorZ&) = delete;
9393 CResult_BlindedHopFeaturesDecodeErrorZ(CResult_BlindedHopFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); }
9394 CResult_BlindedHopFeaturesDecodeErrorZ(LDKCResult_BlindedHopFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); }
9395 operator LDKCResult_BlindedHopFeaturesDecodeErrorZ() && { LDKCResult_BlindedHopFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ)); return res; }
9396 ~CResult_BlindedHopFeaturesDecodeErrorZ() { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); }
9397 CResult_BlindedHopFeaturesDecodeErrorZ& operator=(CResult_BlindedHopFeaturesDecodeErrorZ&& o) { CResult_BlindedHopFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedHopFeaturesDecodeErrorZ)); return *this; }
9398 LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() { return &self; }
9399 LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() { return &self; }
9400 const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator &() const { return &self; }
9401 const LDKCResult_BlindedHopFeaturesDecodeErrorZ* operator ->() const { return &self; }
9403 class CVec_TransactionOutputsZ {
9405 LDKCVec_TransactionOutputsZ self;
9407 CVec_TransactionOutputsZ(const CVec_TransactionOutputsZ&) = delete;
9408 CVec_TransactionOutputsZ(CVec_TransactionOutputsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); }
9409 CVec_TransactionOutputsZ(LDKCVec_TransactionOutputsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_TransactionOutputsZ)); }
9410 operator LDKCVec_TransactionOutputsZ() && { LDKCVec_TransactionOutputsZ res = self; memset(&self, 0, sizeof(LDKCVec_TransactionOutputsZ)); return res; }
9411 ~CVec_TransactionOutputsZ() { CVec_TransactionOutputsZ_free(self); }
9412 CVec_TransactionOutputsZ& operator=(CVec_TransactionOutputsZ&& o) { CVec_TransactionOutputsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_TransactionOutputsZ)); return *this; }
9413 LDKCVec_TransactionOutputsZ* operator &() { return &self; }
9414 LDKCVec_TransactionOutputsZ* operator ->() { return &self; }
9415 const LDKCVec_TransactionOutputsZ* operator &() const { return &self; }
9416 const LDKCVec_TransactionOutputsZ* operator ->() const { return &self; }
9418 class COption_HTLCClaimZ {
9420 LDKCOption_HTLCClaimZ self;
9422 COption_HTLCClaimZ(const COption_HTLCClaimZ&) = delete;
9423 COption_HTLCClaimZ(COption_HTLCClaimZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_HTLCClaimZ)); }
9424 COption_HTLCClaimZ(LDKCOption_HTLCClaimZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_HTLCClaimZ)); }
9425 operator LDKCOption_HTLCClaimZ() && { LDKCOption_HTLCClaimZ res = self; memset(&self, 0, sizeof(LDKCOption_HTLCClaimZ)); return res; }
9426 ~COption_HTLCClaimZ() { COption_HTLCClaimZ_free(self); }
9427 COption_HTLCClaimZ& operator=(COption_HTLCClaimZ&& o) { COption_HTLCClaimZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_HTLCClaimZ)); return *this; }
9428 LDKCOption_HTLCClaimZ* operator &() { return &self; }
9429 LDKCOption_HTLCClaimZ* operator ->() { return &self; }
9430 const LDKCOption_HTLCClaimZ* operator &() const { return &self; }
9431 const LDKCOption_HTLCClaimZ* operator ->() const { return &self; }
9433 class COption_boolZ {
9435 LDKCOption_boolZ self;
9437 COption_boolZ(const COption_boolZ&) = delete;
9438 COption_boolZ(COption_boolZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_boolZ)); }
9439 COption_boolZ(LDKCOption_boolZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_boolZ)); }
9440 operator LDKCOption_boolZ() && { LDKCOption_boolZ res = self; memset(&self, 0, sizeof(LDKCOption_boolZ)); return res; }
9441 ~COption_boolZ() { COption_boolZ_free(self); }
9442 COption_boolZ& operator=(COption_boolZ&& o) { COption_boolZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_boolZ)); return *this; }
9443 LDKCOption_boolZ* operator &() { return &self; }
9444 LDKCOption_boolZ* operator ->() { return &self; }
9445 const LDKCOption_boolZ* operator &() const { return &self; }
9446 const LDKCOption_boolZ* operator ->() const { return &self; }
9448 class CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ {
9450 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ self;
9452 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(const CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&) = delete;
9453 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
9454 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); }
9455 operator LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ)); return res; }
9456 ~CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ() { CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(self); }
9457 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; }
9458 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() { return &self; }
9459 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() { return &self; }
9460 const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator &() const { return &self; }
9461 const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ* operator ->() const { return &self; }
9463 class CResult_ProbabilisticScorerDecodeErrorZ {
9465 LDKCResult_ProbabilisticScorerDecodeErrorZ self;
9467 CResult_ProbabilisticScorerDecodeErrorZ(const CResult_ProbabilisticScorerDecodeErrorZ&) = delete;
9468 CResult_ProbabilisticScorerDecodeErrorZ(CResult_ProbabilisticScorerDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); }
9469 CResult_ProbabilisticScorerDecodeErrorZ(LDKCResult_ProbabilisticScorerDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); }
9470 operator LDKCResult_ProbabilisticScorerDecodeErrorZ() && { LDKCResult_ProbabilisticScorerDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ)); return res; }
9471 ~CResult_ProbabilisticScorerDecodeErrorZ() { CResult_ProbabilisticScorerDecodeErrorZ_free(self); }
9472 CResult_ProbabilisticScorerDecodeErrorZ& operator=(CResult_ProbabilisticScorerDecodeErrorZ&& o) { CResult_ProbabilisticScorerDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ProbabilisticScorerDecodeErrorZ)); return *this; }
9473 LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() { return &self; }
9474 LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() { return &self; }
9475 const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator &() const { return &self; }
9476 const LDKCResult_ProbabilisticScorerDecodeErrorZ* operator ->() const { return &self; }
9478 class COption_StrZ {
9480 LDKCOption_StrZ self;
9482 COption_StrZ(const COption_StrZ&) = delete;
9483 COption_StrZ(COption_StrZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_StrZ)); }
9484 COption_StrZ(LDKCOption_StrZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_StrZ)); }
9485 operator LDKCOption_StrZ() && { LDKCOption_StrZ res = self; memset(&self, 0, sizeof(LDKCOption_StrZ)); return res; }
9486 ~COption_StrZ() { COption_StrZ_free(self); }
9487 COption_StrZ& operator=(COption_StrZ&& o) { COption_StrZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_StrZ)); return *this; }
9488 LDKCOption_StrZ* operator &() { return &self; }
9489 LDKCOption_StrZ* operator ->() { return &self; }
9490 const LDKCOption_StrZ* operator &() const { return &self; }
9491 const LDKCOption_StrZ* operator ->() const { return &self; }
9493 class CResult_ShutdownScriptDecodeErrorZ {
9495 LDKCResult_ShutdownScriptDecodeErrorZ self;
9497 CResult_ShutdownScriptDecodeErrorZ(const CResult_ShutdownScriptDecodeErrorZ&) = delete;
9498 CResult_ShutdownScriptDecodeErrorZ(CResult_ShutdownScriptDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); }
9499 CResult_ShutdownScriptDecodeErrorZ(LDKCResult_ShutdownScriptDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); }
9500 operator LDKCResult_ShutdownScriptDecodeErrorZ() && { LDKCResult_ShutdownScriptDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownScriptDecodeErrorZ)); return res; }
9501 ~CResult_ShutdownScriptDecodeErrorZ() { CResult_ShutdownScriptDecodeErrorZ_free(self); }
9502 CResult_ShutdownScriptDecodeErrorZ& operator=(CResult_ShutdownScriptDecodeErrorZ&& o) { CResult_ShutdownScriptDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownScriptDecodeErrorZ)); return *this; }
9503 LDKCResult_ShutdownScriptDecodeErrorZ* operator &() { return &self; }
9504 LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() { return &self; }
9505 const LDKCResult_ShutdownScriptDecodeErrorZ* operator &() const { return &self; }
9506 const LDKCResult_ShutdownScriptDecodeErrorZ* operator ->() const { return &self; }
9508 class CResult_SiPrefixBolt11ParseErrorZ {
9510 LDKCResult_SiPrefixBolt11ParseErrorZ self;
9512 CResult_SiPrefixBolt11ParseErrorZ(const CResult_SiPrefixBolt11ParseErrorZ&) = delete;
9513 CResult_SiPrefixBolt11ParseErrorZ(CResult_SiPrefixBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); }
9514 CResult_SiPrefixBolt11ParseErrorZ(LDKCResult_SiPrefixBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); }
9515 operator LDKCResult_SiPrefixBolt11ParseErrorZ() && { LDKCResult_SiPrefixBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ)); return res; }
9516 ~CResult_SiPrefixBolt11ParseErrorZ() { CResult_SiPrefixBolt11ParseErrorZ_free(self); }
9517 CResult_SiPrefixBolt11ParseErrorZ& operator=(CResult_SiPrefixBolt11ParseErrorZ&& o) { CResult_SiPrefixBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SiPrefixBolt11ParseErrorZ)); return *this; }
9518 LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() { return &self; }
9519 LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() { return &self; }
9520 const LDKCResult_SiPrefixBolt11ParseErrorZ* operator &() const { return &self; }
9521 const LDKCResult_SiPrefixBolt11ParseErrorZ* operator ->() const { return &self; }
9523 class C2Tuple_usizeTransactionZ {
9525 LDKC2Tuple_usizeTransactionZ self;
9527 C2Tuple_usizeTransactionZ(const C2Tuple_usizeTransactionZ&) = delete;
9528 C2Tuple_usizeTransactionZ(C2Tuple_usizeTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); }
9529 C2Tuple_usizeTransactionZ(LDKC2Tuple_usizeTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); }
9530 operator LDKC2Tuple_usizeTransactionZ() && { LDKC2Tuple_usizeTransactionZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_usizeTransactionZ)); return res; }
9531 ~C2Tuple_usizeTransactionZ() { C2Tuple_usizeTransactionZ_free(self); }
9532 C2Tuple_usizeTransactionZ& operator=(C2Tuple_usizeTransactionZ&& o) { C2Tuple_usizeTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_usizeTransactionZ)); return *this; }
9533 LDKC2Tuple_usizeTransactionZ* operator &() { return &self; }
9534 LDKC2Tuple_usizeTransactionZ* operator ->() { return &self; }
9535 const LDKC2Tuple_usizeTransactionZ* operator &() const { return &self; }
9536 const LDKC2Tuple_usizeTransactionZ* operator ->() const { return &self; }
9538 class CResult_NodeAnnouncementDecodeErrorZ {
9540 LDKCResult_NodeAnnouncementDecodeErrorZ self;
9542 CResult_NodeAnnouncementDecodeErrorZ(const CResult_NodeAnnouncementDecodeErrorZ&) = delete;
9543 CResult_NodeAnnouncementDecodeErrorZ(CResult_NodeAnnouncementDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); }
9544 CResult_NodeAnnouncementDecodeErrorZ(LDKCResult_NodeAnnouncementDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); }
9545 operator LDKCResult_NodeAnnouncementDecodeErrorZ() && { LDKCResult_NodeAnnouncementDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ)); return res; }
9546 ~CResult_NodeAnnouncementDecodeErrorZ() { CResult_NodeAnnouncementDecodeErrorZ_free(self); }
9547 CResult_NodeAnnouncementDecodeErrorZ& operator=(CResult_NodeAnnouncementDecodeErrorZ&& o) { CResult_NodeAnnouncementDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeAnnouncementDecodeErrorZ)); return *this; }
9548 LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() { return &self; }
9549 LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() { return &self; }
9550 const LDKCResult_NodeAnnouncementDecodeErrorZ* operator &() const { return &self; }
9551 const LDKCResult_NodeAnnouncementDecodeErrorZ* operator ->() const { return &self; }
9553 class CVec_FutureZ {
9555 LDKCVec_FutureZ self;
9557 CVec_FutureZ(const CVec_FutureZ&) = delete;
9558 CVec_FutureZ(CVec_FutureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_FutureZ)); }
9559 CVec_FutureZ(LDKCVec_FutureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_FutureZ)); }
9560 operator LDKCVec_FutureZ() && { LDKCVec_FutureZ res = self; memset(&self, 0, sizeof(LDKCVec_FutureZ)); return res; }
9561 ~CVec_FutureZ() { CVec_FutureZ_free(self); }
9562 CVec_FutureZ& operator=(CVec_FutureZ&& o) { CVec_FutureZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_FutureZ)); return *this; }
9563 LDKCVec_FutureZ* operator &() { return &self; }
9564 LDKCVec_FutureZ* operator ->() { return &self; }
9565 const LDKCVec_FutureZ* operator &() const { return &self; }
9566 const LDKCVec_FutureZ* operator ->() const { return &self; }
9568 class CVec_ChannelMonitorZ {
9570 LDKCVec_ChannelMonitorZ self;
9572 CVec_ChannelMonitorZ(const CVec_ChannelMonitorZ&) = delete;
9573 CVec_ChannelMonitorZ(CVec_ChannelMonitorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); }
9574 CVec_ChannelMonitorZ(LDKCVec_ChannelMonitorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelMonitorZ)); }
9575 operator LDKCVec_ChannelMonitorZ() && { LDKCVec_ChannelMonitorZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelMonitorZ)); return res; }
9576 ~CVec_ChannelMonitorZ() { CVec_ChannelMonitorZ_free(self); }
9577 CVec_ChannelMonitorZ& operator=(CVec_ChannelMonitorZ&& o) { CVec_ChannelMonitorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelMonitorZ)); return *this; }
9578 LDKCVec_ChannelMonitorZ* operator &() { return &self; }
9579 LDKCVec_ChannelMonitorZ* operator ->() { return &self; }
9580 const LDKCVec_ChannelMonitorZ* operator &() const { return &self; }
9581 const LDKCVec_ChannelMonitorZ* operator ->() const { return &self; }
9583 class CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ {
9585 LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ self;
9587 CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(const CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&) = delete;
9588 CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
9589 CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); }
9590 operator LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() && { LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return res; }
9591 ~CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ() { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); }
9592 CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ& operator=(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ&& o) { CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ)); return *this; }
9593 LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() { return &self; }
9594 LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() { return &self; }
9595 const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator &() const { return &self; }
9596 const LDKCVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ* operator ->() const { return &self; }
9598 class CResult_AcceptChannelV2DecodeErrorZ {
9600 LDKCResult_AcceptChannelV2DecodeErrorZ self;
9602 CResult_AcceptChannelV2DecodeErrorZ(const CResult_AcceptChannelV2DecodeErrorZ&) = delete;
9603 CResult_AcceptChannelV2DecodeErrorZ(CResult_AcceptChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); }
9604 CResult_AcceptChannelV2DecodeErrorZ(LDKCResult_AcceptChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); }
9605 operator LDKCResult_AcceptChannelV2DecodeErrorZ() && { LDKCResult_AcceptChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ)); return res; }
9606 ~CResult_AcceptChannelV2DecodeErrorZ() { CResult_AcceptChannelV2DecodeErrorZ_free(self); }
9607 CResult_AcceptChannelV2DecodeErrorZ& operator=(CResult_AcceptChannelV2DecodeErrorZ&& o) { CResult_AcceptChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelV2DecodeErrorZ)); return *this; }
9608 LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() { return &self; }
9609 LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() { return &self; }
9610 const LDKCResult_AcceptChannelV2DecodeErrorZ* operator &() const { return &self; }
9611 const LDKCResult_AcceptChannelV2DecodeErrorZ* operator ->() const { return &self; }
9613 class CResult_RouteHopDecodeErrorZ {
9615 LDKCResult_RouteHopDecodeErrorZ self;
9617 CResult_RouteHopDecodeErrorZ(const CResult_RouteHopDecodeErrorZ&) = delete;
9618 CResult_RouteHopDecodeErrorZ(CResult_RouteHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); }
9619 CResult_RouteHopDecodeErrorZ(LDKCResult_RouteHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); }
9620 operator LDKCResult_RouteHopDecodeErrorZ() && { LDKCResult_RouteHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHopDecodeErrorZ)); return res; }
9621 ~CResult_RouteHopDecodeErrorZ() { CResult_RouteHopDecodeErrorZ_free(self); }
9622 CResult_RouteHopDecodeErrorZ& operator=(CResult_RouteHopDecodeErrorZ&& o) { CResult_RouteHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHopDecodeErrorZ)); return *this; }
9623 LDKCResult_RouteHopDecodeErrorZ* operator &() { return &self; }
9624 LDKCResult_RouteHopDecodeErrorZ* operator ->() { return &self; }
9625 const LDKCResult_RouteHopDecodeErrorZ* operator &() const { return &self; }
9626 const LDKCResult_RouteHopDecodeErrorZ* operator ->() const { return &self; }
9628 class CVec_HTLCOutputInCommitmentZ {
9630 LDKCVec_HTLCOutputInCommitmentZ self;
9632 CVec_HTLCOutputInCommitmentZ(const CVec_HTLCOutputInCommitmentZ&) = delete;
9633 CVec_HTLCOutputInCommitmentZ(CVec_HTLCOutputInCommitmentZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); }
9634 CVec_HTLCOutputInCommitmentZ(LDKCVec_HTLCOutputInCommitmentZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); }
9635 operator LDKCVec_HTLCOutputInCommitmentZ() && { LDKCVec_HTLCOutputInCommitmentZ res = self; memset(&self, 0, sizeof(LDKCVec_HTLCOutputInCommitmentZ)); return res; }
9636 ~CVec_HTLCOutputInCommitmentZ() { CVec_HTLCOutputInCommitmentZ_free(self); }
9637 CVec_HTLCOutputInCommitmentZ& operator=(CVec_HTLCOutputInCommitmentZ&& o) { CVec_HTLCOutputInCommitmentZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_HTLCOutputInCommitmentZ)); return *this; }
9638 LDKCVec_HTLCOutputInCommitmentZ* operator &() { return &self; }
9639 LDKCVec_HTLCOutputInCommitmentZ* operator ->() { return &self; }
9640 const LDKCVec_HTLCOutputInCommitmentZ* operator &() const { return &self; }
9641 const LDKCVec_HTLCOutputInCommitmentZ* operator ->() const { return &self; }
9643 class CResult_CoinSelectionNoneZ {
9645 LDKCResult_CoinSelectionNoneZ self;
9647 CResult_CoinSelectionNoneZ(const CResult_CoinSelectionNoneZ&) = delete;
9648 CResult_CoinSelectionNoneZ(CResult_CoinSelectionNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); }
9649 CResult_CoinSelectionNoneZ(LDKCResult_CoinSelectionNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); }
9650 operator LDKCResult_CoinSelectionNoneZ() && { LDKCResult_CoinSelectionNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CoinSelectionNoneZ)); return res; }
9651 ~CResult_CoinSelectionNoneZ() { CResult_CoinSelectionNoneZ_free(self); }
9652 CResult_CoinSelectionNoneZ& operator=(CResult_CoinSelectionNoneZ&& o) { CResult_CoinSelectionNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CoinSelectionNoneZ)); return *this; }
9653 LDKCResult_CoinSelectionNoneZ* operator &() { return &self; }
9654 LDKCResult_CoinSelectionNoneZ* operator ->() { return &self; }
9655 const LDKCResult_CoinSelectionNoneZ* operator &() const { return &self; }
9656 const LDKCResult_CoinSelectionNoneZ* operator ->() const { return &self; }
9658 class C2Tuple_ThirtyTwoBytesPublicKeyZ {
9660 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ self;
9662 C2Tuple_ThirtyTwoBytesPublicKeyZ(const C2Tuple_ThirtyTwoBytesPublicKeyZ&) = delete;
9663 C2Tuple_ThirtyTwoBytesPublicKeyZ(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); }
9664 C2Tuple_ThirtyTwoBytesPublicKeyZ(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); }
9665 operator LDKC2Tuple_ThirtyTwoBytesPublicKeyZ() && { LDKC2Tuple_ThirtyTwoBytesPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ)); return res; }
9666 ~C2Tuple_ThirtyTwoBytesPublicKeyZ() { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); }
9667 C2Tuple_ThirtyTwoBytesPublicKeyZ& operator=(C2Tuple_ThirtyTwoBytesPublicKeyZ&& o) { C2Tuple_ThirtyTwoBytesPublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesPublicKeyZ)); return *this; }
9668 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() { return &self; }
9669 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() { return &self; }
9670 const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator &() const { return &self; }
9671 const LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* operator ->() const { return &self; }
9673 class CResult_TxCreationKeysDecodeErrorZ {
9675 LDKCResult_TxCreationKeysDecodeErrorZ self;
9677 CResult_TxCreationKeysDecodeErrorZ(const CResult_TxCreationKeysDecodeErrorZ&) = delete;
9678 CResult_TxCreationKeysDecodeErrorZ(CResult_TxCreationKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); }
9679 CResult_TxCreationKeysDecodeErrorZ(LDKCResult_TxCreationKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); }
9680 operator LDKCResult_TxCreationKeysDecodeErrorZ() && { LDKCResult_TxCreationKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxCreationKeysDecodeErrorZ)); return res; }
9681 ~CResult_TxCreationKeysDecodeErrorZ() { CResult_TxCreationKeysDecodeErrorZ_free(self); }
9682 CResult_TxCreationKeysDecodeErrorZ& operator=(CResult_TxCreationKeysDecodeErrorZ&& o) { CResult_TxCreationKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxCreationKeysDecodeErrorZ)); return *this; }
9683 LDKCResult_TxCreationKeysDecodeErrorZ* operator &() { return &self; }
9684 LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() { return &self; }
9685 const LDKCResult_TxCreationKeysDecodeErrorZ* operator &() const { return &self; }
9686 const LDKCResult_TxCreationKeysDecodeErrorZ* operator ->() const { return &self; }
9688 class CResult_BlindedPathDecodeErrorZ {
9690 LDKCResult_BlindedPathDecodeErrorZ self;
9692 CResult_BlindedPathDecodeErrorZ(const CResult_BlindedPathDecodeErrorZ&) = delete;
9693 CResult_BlindedPathDecodeErrorZ(CResult_BlindedPathDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); }
9694 CResult_BlindedPathDecodeErrorZ(LDKCResult_BlindedPathDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); }
9695 operator LDKCResult_BlindedPathDecodeErrorZ() && { LDKCResult_BlindedPathDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathDecodeErrorZ)); return res; }
9696 ~CResult_BlindedPathDecodeErrorZ() { CResult_BlindedPathDecodeErrorZ_free(self); }
9697 CResult_BlindedPathDecodeErrorZ& operator=(CResult_BlindedPathDecodeErrorZ&& o) { CResult_BlindedPathDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathDecodeErrorZ)); return *this; }
9698 LDKCResult_BlindedPathDecodeErrorZ* operator &() { return &self; }
9699 LDKCResult_BlindedPathDecodeErrorZ* operator ->() { return &self; }
9700 const LDKCResult_BlindedPathDecodeErrorZ* operator &() const { return &self; }
9701 const LDKCResult_BlindedPathDecodeErrorZ* operator ->() const { return &self; }
9703 class CVec_BalanceZ {
9705 LDKCVec_BalanceZ self;
9707 CVec_BalanceZ(const CVec_BalanceZ&) = delete;
9708 CVec_BalanceZ(CVec_BalanceZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_BalanceZ)); }
9709 CVec_BalanceZ(LDKCVec_BalanceZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_BalanceZ)); }
9710 operator LDKCVec_BalanceZ() && { LDKCVec_BalanceZ res = self; memset(&self, 0, sizeof(LDKCVec_BalanceZ)); return res; }
9711 ~CVec_BalanceZ() { CVec_BalanceZ_free(self); }
9712 CVec_BalanceZ& operator=(CVec_BalanceZ&& o) { CVec_BalanceZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_BalanceZ)); return *this; }
9713 LDKCVec_BalanceZ* operator &() { return &self; }
9714 LDKCVec_BalanceZ* operator ->() { return &self; }
9715 const LDKCVec_BalanceZ* operator &() const { return &self; }
9716 const LDKCVec_BalanceZ* operator ->() const { return &self; }
9718 class CResult_NoneIOErrorZ {
9720 LDKCResult_NoneIOErrorZ self;
9722 CResult_NoneIOErrorZ(const CResult_NoneIOErrorZ&) = delete;
9723 CResult_NoneIOErrorZ(CResult_NoneIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); }
9724 CResult_NoneIOErrorZ(LDKCResult_NoneIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneIOErrorZ)); }
9725 operator LDKCResult_NoneIOErrorZ() && { LDKCResult_NoneIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneIOErrorZ)); return res; }
9726 ~CResult_NoneIOErrorZ() { CResult_NoneIOErrorZ_free(self); }
9727 CResult_NoneIOErrorZ& operator=(CResult_NoneIOErrorZ&& o) { CResult_NoneIOErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneIOErrorZ)); return *this; }
9728 LDKCResult_NoneIOErrorZ* operator &() { return &self; }
9729 LDKCResult_NoneIOErrorZ* operator ->() { return &self; }
9730 const LDKCResult_NoneIOErrorZ* operator &() const { return &self; }
9731 const LDKCResult_NoneIOErrorZ* operator ->() const { return &self; }
9733 class CResult_MaxDustHTLCExposureDecodeErrorZ {
9735 LDKCResult_MaxDustHTLCExposureDecodeErrorZ self;
9737 CResult_MaxDustHTLCExposureDecodeErrorZ(const CResult_MaxDustHTLCExposureDecodeErrorZ&) = delete;
9738 CResult_MaxDustHTLCExposureDecodeErrorZ(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); }
9739 CResult_MaxDustHTLCExposureDecodeErrorZ(LDKCResult_MaxDustHTLCExposureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); }
9740 operator LDKCResult_MaxDustHTLCExposureDecodeErrorZ() && { LDKCResult_MaxDustHTLCExposureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ)); return res; }
9741 ~CResult_MaxDustHTLCExposureDecodeErrorZ() { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); }
9742 CResult_MaxDustHTLCExposureDecodeErrorZ& operator=(CResult_MaxDustHTLCExposureDecodeErrorZ&& o) { CResult_MaxDustHTLCExposureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_MaxDustHTLCExposureDecodeErrorZ)); return *this; }
9743 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() { return &self; }
9744 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() { return &self; }
9745 const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator &() const { return &self; }
9746 const LDKCResult_MaxDustHTLCExposureDecodeErrorZ* operator ->() const { return &self; }
9748 class CVec_CommitmentTransactionZ {
9750 LDKCVec_CommitmentTransactionZ self;
9752 CVec_CommitmentTransactionZ(const CVec_CommitmentTransactionZ&) = delete;
9753 CVec_CommitmentTransactionZ(CVec_CommitmentTransactionZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); }
9754 CVec_CommitmentTransactionZ(LDKCVec_CommitmentTransactionZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); }
9755 operator LDKCVec_CommitmentTransactionZ() && { LDKCVec_CommitmentTransactionZ res = self; memset(&self, 0, sizeof(LDKCVec_CommitmentTransactionZ)); return res; }
9756 ~CVec_CommitmentTransactionZ() { CVec_CommitmentTransactionZ_free(self); }
9757 CVec_CommitmentTransactionZ& operator=(CVec_CommitmentTransactionZ&& o) { CVec_CommitmentTransactionZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_CommitmentTransactionZ)); return *this; }
9758 LDKCVec_CommitmentTransactionZ* operator &() { return &self; }
9759 LDKCVec_CommitmentTransactionZ* operator ->() { return &self; }
9760 const LDKCVec_CommitmentTransactionZ* operator &() const { return &self; }
9761 const LDKCVec_CommitmentTransactionZ* operator ->() const { return &self; }
9763 class CResult_FundingSignedDecodeErrorZ {
9765 LDKCResult_FundingSignedDecodeErrorZ self;
9767 CResult_FundingSignedDecodeErrorZ(const CResult_FundingSignedDecodeErrorZ&) = delete;
9768 CResult_FundingSignedDecodeErrorZ(CResult_FundingSignedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); }
9769 CResult_FundingSignedDecodeErrorZ(LDKCResult_FundingSignedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); }
9770 operator LDKCResult_FundingSignedDecodeErrorZ() && { LDKCResult_FundingSignedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_FundingSignedDecodeErrorZ)); return res; }
9771 ~CResult_FundingSignedDecodeErrorZ() { CResult_FundingSignedDecodeErrorZ_free(self); }
9772 CResult_FundingSignedDecodeErrorZ& operator=(CResult_FundingSignedDecodeErrorZ&& o) { CResult_FundingSignedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_FundingSignedDecodeErrorZ)); return *this; }
9773 LDKCResult_FundingSignedDecodeErrorZ* operator &() { return &self; }
9774 LDKCResult_FundingSignedDecodeErrorZ* operator ->() { return &self; }
9775 const LDKCResult_FundingSignedDecodeErrorZ* operator &() const { return &self; }
9776 const LDKCResult_FundingSignedDecodeErrorZ* operator ->() const { return &self; }
9778 class CResult_RecoverableSignatureNoneZ {
9780 LDKCResult_RecoverableSignatureNoneZ self;
9782 CResult_RecoverableSignatureNoneZ(const CResult_RecoverableSignatureNoneZ&) = delete;
9783 CResult_RecoverableSignatureNoneZ(CResult_RecoverableSignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); }
9784 CResult_RecoverableSignatureNoneZ(LDKCResult_RecoverableSignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); }
9785 operator LDKCResult_RecoverableSignatureNoneZ() && { LDKCResult_RecoverableSignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_RecoverableSignatureNoneZ)); return res; }
9786 ~CResult_RecoverableSignatureNoneZ() { CResult_RecoverableSignatureNoneZ_free(self); }
9787 CResult_RecoverableSignatureNoneZ& operator=(CResult_RecoverableSignatureNoneZ&& o) { CResult_RecoverableSignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecoverableSignatureNoneZ)); return *this; }
9788 LDKCResult_RecoverableSignatureNoneZ* operator &() { return &self; }
9789 LDKCResult_RecoverableSignatureNoneZ* operator ->() { return &self; }
9790 const LDKCResult_RecoverableSignatureNoneZ* operator &() const { return &self; }
9791 const LDKCResult_RecoverableSignatureNoneZ* operator ->() const { return &self; }
9793 class CResult_SocketAddressDecodeErrorZ {
9795 LDKCResult_SocketAddressDecodeErrorZ self;
9797 CResult_SocketAddressDecodeErrorZ(const CResult_SocketAddressDecodeErrorZ&) = delete;
9798 CResult_SocketAddressDecodeErrorZ(CResult_SocketAddressDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); }
9799 CResult_SocketAddressDecodeErrorZ(LDKCResult_SocketAddressDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); }
9800 operator LDKCResult_SocketAddressDecodeErrorZ() && { LDKCResult_SocketAddressDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressDecodeErrorZ)); return res; }
9801 ~CResult_SocketAddressDecodeErrorZ() { CResult_SocketAddressDecodeErrorZ_free(self); }
9802 CResult_SocketAddressDecodeErrorZ& operator=(CResult_SocketAddressDecodeErrorZ&& o) { CResult_SocketAddressDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressDecodeErrorZ)); return *this; }
9803 LDKCResult_SocketAddressDecodeErrorZ* operator &() { return &self; }
9804 LDKCResult_SocketAddressDecodeErrorZ* operator ->() { return &self; }
9805 const LDKCResult_SocketAddressDecodeErrorZ* operator &() const { return &self; }
9806 const LDKCResult_SocketAddressDecodeErrorZ* operator ->() const { return &self; }
9812 C2Tuple_Z(const C2Tuple_Z&) = delete;
9813 C2Tuple_Z(C2Tuple_Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_Z)); }
9814 C2Tuple_Z(LDKC2Tuple_Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_Z)); }
9815 operator LDKC2Tuple_Z() && { LDKC2Tuple_Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_Z)); return res; }
9816 ~C2Tuple_Z() { C2Tuple_Z_free(self); }
9817 C2Tuple_Z& operator=(C2Tuple_Z&& o) { C2Tuple_Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_Z)); return *this; }
9818 LDKC2Tuple_Z* operator &() { return &self; }
9819 LDKC2Tuple_Z* operator ->() { return &self; }
9820 const LDKC2Tuple_Z* operator &() const { return &self; }
9821 const LDKC2Tuple_Z* operator ->() const { return &self; }
9823 class C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ {
9825 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ self;
9827 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(const C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&) = delete;
9828 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9829 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); }
9830 operator LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() && { LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ)); return res; }
9831 ~C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ() { C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(self); }
9832 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; }
9833 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() { return &self; }
9834 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() { return &self; }
9835 const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator &() const { return &self; }
9836 const LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* operator ->() const { return &self; }
9842 CVec_PathZ(const CVec_PathZ&) = delete;
9843 CVec_PathZ(CVec_PathZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PathZ)); }
9844 CVec_PathZ(LDKCVec_PathZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PathZ)); }
9845 operator LDKCVec_PathZ() && { LDKCVec_PathZ res = self; memset(&self, 0, sizeof(LDKCVec_PathZ)); return res; }
9846 ~CVec_PathZ() { CVec_PathZ_free(self); }
9847 CVec_PathZ& operator=(CVec_PathZ&& o) { CVec_PathZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PathZ)); return *this; }
9848 LDKCVec_PathZ* operator &() { return &self; }
9849 LDKCVec_PathZ* operator ->() { return &self; }
9850 const LDKCVec_PathZ* operator &() const { return &self; }
9851 const LDKCVec_PathZ* operator ->() const { return &self; }
9853 class CResult_NetworkGraphDecodeErrorZ {
9855 LDKCResult_NetworkGraphDecodeErrorZ self;
9857 CResult_NetworkGraphDecodeErrorZ(const CResult_NetworkGraphDecodeErrorZ&) = delete;
9858 CResult_NetworkGraphDecodeErrorZ(CResult_NetworkGraphDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); }
9859 CResult_NetworkGraphDecodeErrorZ(LDKCResult_NetworkGraphDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); }
9860 operator LDKCResult_NetworkGraphDecodeErrorZ() && { LDKCResult_NetworkGraphDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NetworkGraphDecodeErrorZ)); return res; }
9861 ~CResult_NetworkGraphDecodeErrorZ() { CResult_NetworkGraphDecodeErrorZ_free(self); }
9862 CResult_NetworkGraphDecodeErrorZ& operator=(CResult_NetworkGraphDecodeErrorZ&& o) { CResult_NetworkGraphDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NetworkGraphDecodeErrorZ)); return *this; }
9863 LDKCResult_NetworkGraphDecodeErrorZ* operator &() { return &self; }
9864 LDKCResult_NetworkGraphDecodeErrorZ* operator ->() { return &self; }
9865 const LDKCResult_NetworkGraphDecodeErrorZ* operator &() const { return &self; }
9866 const LDKCResult_NetworkGraphDecodeErrorZ* operator ->() const { return &self; }
9868 class CResult_NodeInfoDecodeErrorZ {
9870 LDKCResult_NodeInfoDecodeErrorZ self;
9872 CResult_NodeInfoDecodeErrorZ(const CResult_NodeInfoDecodeErrorZ&) = delete;
9873 CResult_NodeInfoDecodeErrorZ(CResult_NodeInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); }
9874 CResult_NodeInfoDecodeErrorZ(LDKCResult_NodeInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); }
9875 operator LDKCResult_NodeInfoDecodeErrorZ() && { LDKCResult_NodeInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NodeInfoDecodeErrorZ)); return res; }
9876 ~CResult_NodeInfoDecodeErrorZ() { CResult_NodeInfoDecodeErrorZ_free(self); }
9877 CResult_NodeInfoDecodeErrorZ& operator=(CResult_NodeInfoDecodeErrorZ&& o) { CResult_NodeInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NodeInfoDecodeErrorZ)); return *this; }
9878 LDKCResult_NodeInfoDecodeErrorZ* operator &() { return &self; }
9879 LDKCResult_NodeInfoDecodeErrorZ* operator ->() { return &self; }
9880 const LDKCResult_NodeInfoDecodeErrorZ* operator &() const { return &self; }
9881 const LDKCResult_NodeInfoDecodeErrorZ* operator ->() const { return &self; }
9883 class CVec_NodeIdZ {
9885 LDKCVec_NodeIdZ self;
9887 CVec_NodeIdZ(const CVec_NodeIdZ&) = delete;
9888 CVec_NodeIdZ(CVec_NodeIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_NodeIdZ)); }
9889 CVec_NodeIdZ(LDKCVec_NodeIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_NodeIdZ)); }
9890 operator LDKCVec_NodeIdZ() && { LDKCVec_NodeIdZ res = self; memset(&self, 0, sizeof(LDKCVec_NodeIdZ)); return res; }
9891 ~CVec_NodeIdZ() { CVec_NodeIdZ_free(self); }
9892 CVec_NodeIdZ& operator=(CVec_NodeIdZ&& o) { CVec_NodeIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_NodeIdZ)); return *this; }
9893 LDKCVec_NodeIdZ* operator &() { return &self; }
9894 LDKCVec_NodeIdZ* operator ->() { return &self; }
9895 const LDKCVec_NodeIdZ* operator &() const { return &self; }
9896 const LDKCVec_NodeIdZ* operator ->() const { return &self; }
9902 CVec_u8Z(const CVec_u8Z&) = delete;
9903 CVec_u8Z(CVec_u8Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u8Z)); }
9904 CVec_u8Z(LDKCVec_u8Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u8Z)); }
9905 operator LDKCVec_u8Z() && { LDKCVec_u8Z res = self; memset(&self, 0, sizeof(LDKCVec_u8Z)); return res; }
9906 ~CVec_u8Z() { CVec_u8Z_free(self); }
9907 CVec_u8Z& operator=(CVec_u8Z&& o) { CVec_u8Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u8Z)); return *this; }
9908 LDKCVec_u8Z* operator &() { return &self; }
9909 LDKCVec_u8Z* operator ->() { return &self; }
9910 const LDKCVec_u8Z* operator &() const { return &self; }
9911 const LDKCVec_u8Z* operator ->() const { return &self; }
9913 class CResult_RouteLightningErrorZ {
9915 LDKCResult_RouteLightningErrorZ self;
9917 CResult_RouteLightningErrorZ(const CResult_RouteLightningErrorZ&) = delete;
9918 CResult_RouteLightningErrorZ(CResult_RouteLightningErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); }
9919 CResult_RouteLightningErrorZ(LDKCResult_RouteLightningErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); }
9920 operator LDKCResult_RouteLightningErrorZ() && { LDKCResult_RouteLightningErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteLightningErrorZ)); return res; }
9921 ~CResult_RouteLightningErrorZ() { CResult_RouteLightningErrorZ_free(self); }
9922 CResult_RouteLightningErrorZ& operator=(CResult_RouteLightningErrorZ&& o) { CResult_RouteLightningErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteLightningErrorZ)); return *this; }
9923 LDKCResult_RouteLightningErrorZ* operator &() { return &self; }
9924 LDKCResult_RouteLightningErrorZ* operator ->() { return &self; }
9925 const LDKCResult_RouteLightningErrorZ* operator &() const { return &self; }
9926 const LDKCResult_RouteLightningErrorZ* operator ->() const { return &self; }
9928 class CResult_NonePaymentSendFailureZ {
9930 LDKCResult_NonePaymentSendFailureZ self;
9932 CResult_NonePaymentSendFailureZ(const CResult_NonePaymentSendFailureZ&) = delete;
9933 CResult_NonePaymentSendFailureZ(CResult_NonePaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); }
9934 CResult_NonePaymentSendFailureZ(LDKCResult_NonePaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); }
9935 operator LDKCResult_NonePaymentSendFailureZ() && { LDKCResult_NonePaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_NonePaymentSendFailureZ)); return res; }
9936 ~CResult_NonePaymentSendFailureZ() { CResult_NonePaymentSendFailureZ_free(self); }
9937 CResult_NonePaymentSendFailureZ& operator=(CResult_NonePaymentSendFailureZ&& o) { CResult_NonePaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NonePaymentSendFailureZ)); return *this; }
9938 LDKCResult_NonePaymentSendFailureZ* operator &() { return &self; }
9939 LDKCResult_NonePaymentSendFailureZ* operator ->() { return &self; }
9940 const LDKCResult_NonePaymentSendFailureZ* operator &() const { return &self; }
9941 const LDKCResult_NonePaymentSendFailureZ* operator ->() const { return &self; }
9943 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ {
9945 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ self;
9947 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&) = delete;
9948 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9949 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); }
9950 operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ)); return res; }
9951 ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(self); }
9952 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; }
9953 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() { return &self; }
9954 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() { return &self; }
9955 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator &() const { return &self; }
9956 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* operator ->() const { return &self; }
9958 class CResult_ChannelPublicKeysDecodeErrorZ {
9960 LDKCResult_ChannelPublicKeysDecodeErrorZ self;
9962 CResult_ChannelPublicKeysDecodeErrorZ(const CResult_ChannelPublicKeysDecodeErrorZ&) = delete;
9963 CResult_ChannelPublicKeysDecodeErrorZ(CResult_ChannelPublicKeysDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); }
9964 CResult_ChannelPublicKeysDecodeErrorZ(LDKCResult_ChannelPublicKeysDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); }
9965 operator LDKCResult_ChannelPublicKeysDecodeErrorZ() && { LDKCResult_ChannelPublicKeysDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ)); return res; }
9966 ~CResult_ChannelPublicKeysDecodeErrorZ() { CResult_ChannelPublicKeysDecodeErrorZ_free(self); }
9967 CResult_ChannelPublicKeysDecodeErrorZ& operator=(CResult_ChannelPublicKeysDecodeErrorZ&& o) { CResult_ChannelPublicKeysDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelPublicKeysDecodeErrorZ)); return *this; }
9968 LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() { return &self; }
9969 LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() { return &self; }
9970 const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator &() const { return &self; }
9971 const LDKCResult_ChannelPublicKeysDecodeErrorZ* operator ->() const { return &self; }
9973 class CVec_ClaimedHTLCZ {
9975 LDKCVec_ClaimedHTLCZ self;
9977 CVec_ClaimedHTLCZ(const CVec_ClaimedHTLCZ&) = delete;
9978 CVec_ClaimedHTLCZ(CVec_ClaimedHTLCZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); }
9979 CVec_ClaimedHTLCZ(LDKCVec_ClaimedHTLCZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); }
9980 operator LDKCVec_ClaimedHTLCZ() && { LDKCVec_ClaimedHTLCZ res = self; memset(&self, 0, sizeof(LDKCVec_ClaimedHTLCZ)); return res; }
9981 ~CVec_ClaimedHTLCZ() { CVec_ClaimedHTLCZ_free(self); }
9982 CVec_ClaimedHTLCZ& operator=(CVec_ClaimedHTLCZ&& o) { CVec_ClaimedHTLCZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ClaimedHTLCZ)); return *this; }
9983 LDKCVec_ClaimedHTLCZ* operator &() { return &self; }
9984 LDKCVec_ClaimedHTLCZ* operator ->() { return &self; }
9985 const LDKCVec_ClaimedHTLCZ* operator &() const { return &self; }
9986 const LDKCVec_ClaimedHTLCZ* operator ->() const { return &self; }
9988 class COption_CVec_ThirtyTwoBytesZZ {
9990 LDKCOption_CVec_ThirtyTwoBytesZZ self;
9992 COption_CVec_ThirtyTwoBytesZZ(const COption_CVec_ThirtyTwoBytesZZ&) = delete;
9993 COption_CVec_ThirtyTwoBytesZZ(COption_CVec_ThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_ThirtyTwoBytesZZ)); }
9994 COption_CVec_ThirtyTwoBytesZZ(LDKCOption_CVec_ThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); }
9995 operator LDKCOption_CVec_ThirtyTwoBytesZZ() && { LDKCOption_CVec_ThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ)); return res; }
9996 ~COption_CVec_ThirtyTwoBytesZZ() { COption_CVec_ThirtyTwoBytesZZ_free(self); }
9997 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; }
9998 LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() { return &self; }
9999 LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() { return &self; }
10000 const LDKCOption_CVec_ThirtyTwoBytesZZ* operator &() const { return &self; }
10001 const LDKCOption_CVec_ThirtyTwoBytesZZ* operator ->() const { return &self; }
10003 class CVec_SocketAddressZ {
10005 LDKCVec_SocketAddressZ self;
10007 CVec_SocketAddressZ(const CVec_SocketAddressZ&) = delete;
10008 CVec_SocketAddressZ(CVec_SocketAddressZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_SocketAddressZ)); }
10009 CVec_SocketAddressZ(LDKCVec_SocketAddressZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_SocketAddressZ)); }
10010 operator LDKCVec_SocketAddressZ() && { LDKCVec_SocketAddressZ res = self; memset(&self, 0, sizeof(LDKCVec_SocketAddressZ)); return res; }
10011 ~CVec_SocketAddressZ() { CVec_SocketAddressZ_free(self); }
10012 CVec_SocketAddressZ& operator=(CVec_SocketAddressZ&& o) { CVec_SocketAddressZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_SocketAddressZ)); return *this; }
10013 LDKCVec_SocketAddressZ* operator &() { return &self; }
10014 LDKCVec_SocketAddressZ* operator ->() { return &self; }
10015 const LDKCVec_SocketAddressZ* operator &() const { return &self; }
10016 const LDKCVec_SocketAddressZ* operator ->() const { return &self; }
10018 class CResult_ThirtyTwoBytesPaymentSendFailureZ {
10020 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ self;
10022 CResult_ThirtyTwoBytesPaymentSendFailureZ(const CResult_ThirtyTwoBytesPaymentSendFailureZ&) = delete;
10023 CResult_ThirtyTwoBytesPaymentSendFailureZ(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); }
10024 CResult_ThirtyTwoBytesPaymentSendFailureZ(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); }
10025 operator LDKCResult_ThirtyTwoBytesPaymentSendFailureZ() && { LDKCResult_ThirtyTwoBytesPaymentSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ)); return res; }
10026 ~CResult_ThirtyTwoBytesPaymentSendFailureZ() { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); }
10027 CResult_ThirtyTwoBytesPaymentSendFailureZ& operator=(CResult_ThirtyTwoBytesPaymentSendFailureZ&& o) { CResult_ThirtyTwoBytesPaymentSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesPaymentSendFailureZ)); return *this; }
10028 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() { return &self; }
10029 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() { return &self; }
10030 const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator &() const { return &self; }
10031 const LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* operator ->() const { return &self; }
10033 class CResult_HolderCommitmentTransactionDecodeErrorZ {
10035 LDKCResult_HolderCommitmentTransactionDecodeErrorZ self;
10037 CResult_HolderCommitmentTransactionDecodeErrorZ(const CResult_HolderCommitmentTransactionDecodeErrorZ&) = delete;
10038 CResult_HolderCommitmentTransactionDecodeErrorZ(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); }
10039 CResult_HolderCommitmentTransactionDecodeErrorZ(LDKCResult_HolderCommitmentTransactionDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); }
10040 operator LDKCResult_HolderCommitmentTransactionDecodeErrorZ() && { LDKCResult_HolderCommitmentTransactionDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ)); return res; }
10041 ~CResult_HolderCommitmentTransactionDecodeErrorZ() { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); }
10042 CResult_HolderCommitmentTransactionDecodeErrorZ& operator=(CResult_HolderCommitmentTransactionDecodeErrorZ&& o) { CResult_HolderCommitmentTransactionDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HolderCommitmentTransactionDecodeErrorZ)); return *this; }
10043 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() { return &self; }
10044 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() { return &self; }
10045 const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator &() const { return &self; }
10046 const LDKCResult_HolderCommitmentTransactionDecodeErrorZ* operator ->() const { return &self; }
10048 class CResult_WarningMessageDecodeErrorZ {
10050 LDKCResult_WarningMessageDecodeErrorZ self;
10052 CResult_WarningMessageDecodeErrorZ(const CResult_WarningMessageDecodeErrorZ&) = delete;
10053 CResult_WarningMessageDecodeErrorZ(CResult_WarningMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); }
10054 CResult_WarningMessageDecodeErrorZ(LDKCResult_WarningMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); }
10055 operator LDKCResult_WarningMessageDecodeErrorZ() && { LDKCResult_WarningMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_WarningMessageDecodeErrorZ)); return res; }
10056 ~CResult_WarningMessageDecodeErrorZ() { CResult_WarningMessageDecodeErrorZ_free(self); }
10057 CResult_WarningMessageDecodeErrorZ& operator=(CResult_WarningMessageDecodeErrorZ&& o) { CResult_WarningMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_WarningMessageDecodeErrorZ)); return *this; }
10058 LDKCResult_WarningMessageDecodeErrorZ* operator &() { return &self; }
10059 LDKCResult_WarningMessageDecodeErrorZ* operator ->() { return &self; }
10060 const LDKCResult_WarningMessageDecodeErrorZ* operator &() const { return &self; }
10061 const LDKCResult_WarningMessageDecodeErrorZ* operator ->() const { return &self; }
10063 class CResult_ChannelCounterpartyDecodeErrorZ {
10065 LDKCResult_ChannelCounterpartyDecodeErrorZ self;
10067 CResult_ChannelCounterpartyDecodeErrorZ(const CResult_ChannelCounterpartyDecodeErrorZ&) = delete;
10068 CResult_ChannelCounterpartyDecodeErrorZ(CResult_ChannelCounterpartyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); }
10069 CResult_ChannelCounterpartyDecodeErrorZ(LDKCResult_ChannelCounterpartyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); }
10070 operator LDKCResult_ChannelCounterpartyDecodeErrorZ() && { LDKCResult_ChannelCounterpartyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ)); return res; }
10071 ~CResult_ChannelCounterpartyDecodeErrorZ() { CResult_ChannelCounterpartyDecodeErrorZ_free(self); }
10072 CResult_ChannelCounterpartyDecodeErrorZ& operator=(CResult_ChannelCounterpartyDecodeErrorZ&& o) { CResult_ChannelCounterpartyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelCounterpartyDecodeErrorZ)); return *this; }
10073 LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() { return &self; }
10074 LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() { return &self; }
10075 const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator &() const { return &self; }
10076 const LDKCResult_ChannelCounterpartyDecodeErrorZ* operator ->() const { return &self; }
10078 class CVec_ForwardNodeZ {
10080 LDKCVec_ForwardNodeZ self;
10082 CVec_ForwardNodeZ(const CVec_ForwardNodeZ&) = delete;
10083 CVec_ForwardNodeZ(CVec_ForwardNodeZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ForwardNodeZ)); }
10084 CVec_ForwardNodeZ(LDKCVec_ForwardNodeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ForwardNodeZ)); }
10085 operator LDKCVec_ForwardNodeZ() && { LDKCVec_ForwardNodeZ res = self; memset(&self, 0, sizeof(LDKCVec_ForwardNodeZ)); return res; }
10086 ~CVec_ForwardNodeZ() { CVec_ForwardNodeZ_free(self); }
10087 CVec_ForwardNodeZ& operator=(CVec_ForwardNodeZ&& o) { CVec_ForwardNodeZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ForwardNodeZ)); return *this; }
10088 LDKCVec_ForwardNodeZ* operator &() { return &self; }
10089 LDKCVec_ForwardNodeZ* operator ->() { return &self; }
10090 const LDKCVec_ForwardNodeZ* operator &() const { return &self; }
10091 const LDKCVec_ForwardNodeZ* operator ->() const { return &self; }
10093 class CResult_DelayedPaymentKeyDecodeErrorZ {
10095 LDKCResult_DelayedPaymentKeyDecodeErrorZ self;
10097 CResult_DelayedPaymentKeyDecodeErrorZ(const CResult_DelayedPaymentKeyDecodeErrorZ&) = delete;
10098 CResult_DelayedPaymentKeyDecodeErrorZ(CResult_DelayedPaymentKeyDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); }
10099 CResult_DelayedPaymentKeyDecodeErrorZ(LDKCResult_DelayedPaymentKeyDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); }
10100 operator LDKCResult_DelayedPaymentKeyDecodeErrorZ() && { LDKCResult_DelayedPaymentKeyDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_DelayedPaymentKeyDecodeErrorZ)); return res; }
10101 ~CResult_DelayedPaymentKeyDecodeErrorZ() { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); }
10102 CResult_DelayedPaymentKeyDecodeErrorZ& operator=(CResult_DelayedPaymentKeyDecodeErrorZ&& o) { CResult_DelayedPaymentKeyDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_DelayedPaymentKeyDecodeErrorZ)); return *this; }
10103 LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() { return &self; }
10104 LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() { return &self; }
10105 const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator &() const { return &self; }
10106 const LDKCResult_DelayedPaymentKeyDecodeErrorZ* operator ->() const { return &self; }
10108 class CResult_InitDecodeErrorZ {
10110 LDKCResult_InitDecodeErrorZ self;
10112 CResult_InitDecodeErrorZ(const CResult_InitDecodeErrorZ&) = delete;
10113 CResult_InitDecodeErrorZ(CResult_InitDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); }
10114 CResult_InitDecodeErrorZ(LDKCResult_InitDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); }
10115 operator LDKCResult_InitDecodeErrorZ() && { LDKCResult_InitDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_InitDecodeErrorZ)); return res; }
10116 ~CResult_InitDecodeErrorZ() { CResult_InitDecodeErrorZ_free(self); }
10117 CResult_InitDecodeErrorZ& operator=(CResult_InitDecodeErrorZ&& o) { CResult_InitDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_InitDecodeErrorZ)); return *this; }
10118 LDKCResult_InitDecodeErrorZ* operator &() { return &self; }
10119 LDKCResult_InitDecodeErrorZ* operator ->() { return &self; }
10120 const LDKCResult_InitDecodeErrorZ* operator &() const { return &self; }
10121 const LDKCResult_InitDecodeErrorZ* operator ->() const { return &self; }
10123 class CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ {
10125 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ self;
10127 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&) = delete;
10128 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
10129 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); }
10130 operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ)); return res; }
10131 ~CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(self); }
10132 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; }
10133 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() { return &self; }
10134 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() { return &self; }
10135 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator &() const { return &self; }
10136 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* operator ->() const { return &self; }
10138 class CResult_SpliceDecodeErrorZ {
10140 LDKCResult_SpliceDecodeErrorZ self;
10142 CResult_SpliceDecodeErrorZ(const CResult_SpliceDecodeErrorZ&) = delete;
10143 CResult_SpliceDecodeErrorZ(CResult_SpliceDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); }
10144 CResult_SpliceDecodeErrorZ(LDKCResult_SpliceDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); }
10145 operator LDKCResult_SpliceDecodeErrorZ() && { LDKCResult_SpliceDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceDecodeErrorZ)); return res; }
10146 ~CResult_SpliceDecodeErrorZ() { CResult_SpliceDecodeErrorZ_free(self); }
10147 CResult_SpliceDecodeErrorZ& operator=(CResult_SpliceDecodeErrorZ&& o) { CResult_SpliceDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceDecodeErrorZ)); return *this; }
10148 LDKCResult_SpliceDecodeErrorZ* operator &() { return &self; }
10149 LDKCResult_SpliceDecodeErrorZ* operator ->() { return &self; }
10150 const LDKCResult_SpliceDecodeErrorZ* operator &() const { return &self; }
10151 const LDKCResult_SpliceDecodeErrorZ* operator ->() const { return &self; }
10153 class CResult_PaymentPurposeDecodeErrorZ {
10155 LDKCResult_PaymentPurposeDecodeErrorZ self;
10157 CResult_PaymentPurposeDecodeErrorZ(const CResult_PaymentPurposeDecodeErrorZ&) = delete;
10158 CResult_PaymentPurposeDecodeErrorZ(CResult_PaymentPurposeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); }
10159 CResult_PaymentPurposeDecodeErrorZ(LDKCResult_PaymentPurposeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); }
10160 operator LDKCResult_PaymentPurposeDecodeErrorZ() && { LDKCResult_PaymentPurposeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentPurposeDecodeErrorZ)); return res; }
10161 ~CResult_PaymentPurposeDecodeErrorZ() { CResult_PaymentPurposeDecodeErrorZ_free(self); }
10162 CResult_PaymentPurposeDecodeErrorZ& operator=(CResult_PaymentPurposeDecodeErrorZ&& o) { CResult_PaymentPurposeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentPurposeDecodeErrorZ)); return *this; }
10163 LDKCResult_PaymentPurposeDecodeErrorZ* operator &() { return &self; }
10164 LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() { return &self; }
10165 const LDKCResult_PaymentPurposeDecodeErrorZ* operator &() const { return &self; }
10166 const LDKCResult_PaymentPurposeDecodeErrorZ* operator ->() const { return &self; }
10168 class CResult_ClaimedHTLCDecodeErrorZ {
10170 LDKCResult_ClaimedHTLCDecodeErrorZ self;
10172 CResult_ClaimedHTLCDecodeErrorZ(const CResult_ClaimedHTLCDecodeErrorZ&) = delete;
10173 CResult_ClaimedHTLCDecodeErrorZ(CResult_ClaimedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); }
10174 CResult_ClaimedHTLCDecodeErrorZ(LDKCResult_ClaimedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); }
10175 operator LDKCResult_ClaimedHTLCDecodeErrorZ() && { LDKCResult_ClaimedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ)); return res; }
10176 ~CResult_ClaimedHTLCDecodeErrorZ() { CResult_ClaimedHTLCDecodeErrorZ_free(self); }
10177 CResult_ClaimedHTLCDecodeErrorZ& operator=(CResult_ClaimedHTLCDecodeErrorZ&& o) { CResult_ClaimedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ClaimedHTLCDecodeErrorZ)); return *this; }
10178 LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() { return &self; }
10179 LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() { return &self; }
10180 const LDKCResult_ClaimedHTLCDecodeErrorZ* operator &() const { return &self; }
10181 const LDKCResult_ClaimedHTLCDecodeErrorZ* operator ->() const { return &self; }
10183 class C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ {
10185 LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ self;
10187 C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(const C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&) = delete;
10188 C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
10189 C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); }
10190 operator LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() && { LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return res; }
10191 ~C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ() { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); }
10192 C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ& operator=(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ&& o) { C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ_free(self); self = o.self; memset(&o, 0, sizeof(C3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ)); return *this; }
10193 LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() { return &self; }
10194 LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() { return &self; }
10195 const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator &() const { return &self; }
10196 const LDKC3Tuple_ThirtyTwoBytesRecipientOnionFieldsRouteParametersZ* operator ->() const { return &self; }
10198 class CResult_OutPointDecodeErrorZ {
10200 LDKCResult_OutPointDecodeErrorZ self;
10202 CResult_OutPointDecodeErrorZ(const CResult_OutPointDecodeErrorZ&) = delete;
10203 CResult_OutPointDecodeErrorZ(CResult_OutPointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); }
10204 CResult_OutPointDecodeErrorZ(LDKCResult_OutPointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); }
10205 operator LDKCResult_OutPointDecodeErrorZ() && { LDKCResult_OutPointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OutPointDecodeErrorZ)); return res; }
10206 ~CResult_OutPointDecodeErrorZ() { CResult_OutPointDecodeErrorZ_free(self); }
10207 CResult_OutPointDecodeErrorZ& operator=(CResult_OutPointDecodeErrorZ&& o) { CResult_OutPointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OutPointDecodeErrorZ)); return *this; }
10208 LDKCResult_OutPointDecodeErrorZ* operator &() { return &self; }
10209 LDKCResult_OutPointDecodeErrorZ* operator ->() { return &self; }
10210 const LDKCResult_OutPointDecodeErrorZ* operator &() const { return &self; }
10211 const LDKCResult_OutPointDecodeErrorZ* operator ->() const { return &self; }
10213 class CVec_ChannelDetailsZ {
10215 LDKCVec_ChannelDetailsZ self;
10217 CVec_ChannelDetailsZ(const CVec_ChannelDetailsZ&) = delete;
10218 CVec_ChannelDetailsZ(CVec_ChannelDetailsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); }
10219 CVec_ChannelDetailsZ(LDKCVec_ChannelDetailsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_ChannelDetailsZ)); }
10220 operator LDKCVec_ChannelDetailsZ() && { LDKCVec_ChannelDetailsZ res = self; memset(&self, 0, sizeof(LDKCVec_ChannelDetailsZ)); return res; }
10221 ~CVec_ChannelDetailsZ() { CVec_ChannelDetailsZ_free(self); }
10222 CVec_ChannelDetailsZ& operator=(CVec_ChannelDetailsZ&& o) { CVec_ChannelDetailsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_ChannelDetailsZ)); return *this; }
10223 LDKCVec_ChannelDetailsZ* operator &() { return &self; }
10224 LDKCVec_ChannelDetailsZ* operator ->() { return &self; }
10225 const LDKCVec_ChannelDetailsZ* operator &() const { return &self; }
10226 const LDKCVec_ChannelDetailsZ* operator ->() const { return &self; }
10228 class CVec_MonitorUpdateIdZ {
10230 LDKCVec_MonitorUpdateIdZ self;
10232 CVec_MonitorUpdateIdZ(const CVec_MonitorUpdateIdZ&) = delete;
10233 CVec_MonitorUpdateIdZ(CVec_MonitorUpdateIdZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); }
10234 CVec_MonitorUpdateIdZ(LDKCVec_MonitorUpdateIdZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); }
10235 operator LDKCVec_MonitorUpdateIdZ() && { LDKCVec_MonitorUpdateIdZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorUpdateIdZ)); return res; }
10236 ~CVec_MonitorUpdateIdZ() { CVec_MonitorUpdateIdZ_free(self); }
10237 CVec_MonitorUpdateIdZ& operator=(CVec_MonitorUpdateIdZ&& o) { CVec_MonitorUpdateIdZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorUpdateIdZ)); return *this; }
10238 LDKCVec_MonitorUpdateIdZ* operator &() { return &self; }
10239 LDKCVec_MonitorUpdateIdZ* operator ->() { return &self; }
10240 const LDKCVec_MonitorUpdateIdZ* operator &() const { return &self; }
10241 const LDKCVec_MonitorUpdateIdZ* operator ->() const { return &self; }
10243 class CResult_Bolt11InvoiceFeaturesDecodeErrorZ {
10245 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ self;
10247 CResult_Bolt11InvoiceFeaturesDecodeErrorZ(const CResult_Bolt11InvoiceFeaturesDecodeErrorZ&) = delete;
10248 CResult_Bolt11InvoiceFeaturesDecodeErrorZ(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
10249 CResult_Bolt11InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); }
10250 operator LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return res; }
10251 ~CResult_Bolt11InvoiceFeaturesDecodeErrorZ() { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); }
10252 CResult_Bolt11InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt11InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt11InvoiceFeaturesDecodeErrorZ)); return *this; }
10253 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10254 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10255 const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10256 const LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10258 class CVec_MessageSendEventZ {
10260 LDKCVec_MessageSendEventZ self;
10262 CVec_MessageSendEventZ(const CVec_MessageSendEventZ&) = delete;
10263 CVec_MessageSendEventZ(CVec_MessageSendEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MessageSendEventZ)); }
10264 CVec_MessageSendEventZ(LDKCVec_MessageSendEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MessageSendEventZ)); }
10265 operator LDKCVec_MessageSendEventZ() && { LDKCVec_MessageSendEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MessageSendEventZ)); return res; }
10266 ~CVec_MessageSendEventZ() { CVec_MessageSendEventZ_free(self); }
10267 CVec_MessageSendEventZ& operator=(CVec_MessageSendEventZ&& o) { CVec_MessageSendEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MessageSendEventZ)); return *this; }
10268 LDKCVec_MessageSendEventZ* operator &() { return &self; }
10269 LDKCVec_MessageSendEventZ* operator ->() { return &self; }
10270 const LDKCVec_MessageSendEventZ* operator &() const { return &self; }
10271 const LDKCVec_MessageSendEventZ* operator ->() const { return &self; }
10273 class CResult_RouteHintHopDecodeErrorZ {
10275 LDKCResult_RouteHintHopDecodeErrorZ self;
10277 CResult_RouteHintHopDecodeErrorZ(const CResult_RouteHintHopDecodeErrorZ&) = delete;
10278 CResult_RouteHintHopDecodeErrorZ(CResult_RouteHintHopDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); }
10279 CResult_RouteHintHopDecodeErrorZ(LDKCResult_RouteHintHopDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); }
10280 operator LDKCResult_RouteHintHopDecodeErrorZ() && { LDKCResult_RouteHintHopDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteHintHopDecodeErrorZ)); return res; }
10281 ~CResult_RouteHintHopDecodeErrorZ() { CResult_RouteHintHopDecodeErrorZ_free(self); }
10282 CResult_RouteHintHopDecodeErrorZ& operator=(CResult_RouteHintHopDecodeErrorZ&& o) { CResult_RouteHintHopDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteHintHopDecodeErrorZ)); return *this; }
10283 LDKCResult_RouteHintHopDecodeErrorZ* operator &() { return &self; }
10284 LDKCResult_RouteHintHopDecodeErrorZ* operator ->() { return &self; }
10285 const LDKCResult_RouteHintHopDecodeErrorZ* operator &() const { return &self; }
10286 const LDKCResult_RouteHintHopDecodeErrorZ* operator ->() const { return &self; }
10288 class CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ {
10290 LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ self;
10292 CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(const CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&) = delete;
10293 CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
10294 CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); }
10295 operator LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() && { LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return res; }
10296 ~CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ() { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); }
10297 CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ& operator=(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ&& o) { CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ)); return *this; }
10298 LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() { return &self; }
10299 LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() { return &self; }
10300 const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator &() const { return &self; }
10301 const LDKCResult_C3Tuple_PublicKeyOnionMessageCOption_CVec_SocketAddressZZZSendErrorZ* operator ->() const { return &self; }
10303 class CResult_UpdateFailMalformedHTLCDecodeErrorZ {
10305 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ self;
10307 CResult_UpdateFailMalformedHTLCDecodeErrorZ(const CResult_UpdateFailMalformedHTLCDecodeErrorZ&) = delete;
10308 CResult_UpdateFailMalformedHTLCDecodeErrorZ(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
10309 CResult_UpdateFailMalformedHTLCDecodeErrorZ(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); }
10310 operator LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ() && { LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ)); return res; }
10311 ~CResult_UpdateFailMalformedHTLCDecodeErrorZ() { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); }
10312 CResult_UpdateFailMalformedHTLCDecodeErrorZ& operator=(CResult_UpdateFailMalformedHTLCDecodeErrorZ&& o) { CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_UpdateFailMalformedHTLCDecodeErrorZ)); return *this; }
10313 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() { return &self; }
10314 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() { return &self; }
10315 const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator &() const { return &self; }
10316 const LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* operator ->() const { return &self; }
10318 class CResult_BlindedPayInfoDecodeErrorZ {
10320 LDKCResult_BlindedPayInfoDecodeErrorZ self;
10322 CResult_BlindedPayInfoDecodeErrorZ(const CResult_BlindedPayInfoDecodeErrorZ&) = delete;
10323 CResult_BlindedPayInfoDecodeErrorZ(CResult_BlindedPayInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); }
10324 CResult_BlindedPayInfoDecodeErrorZ(LDKCResult_BlindedPayInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); }
10325 operator LDKCResult_BlindedPayInfoDecodeErrorZ() && { LDKCResult_BlindedPayInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ)); return res; }
10326 ~CResult_BlindedPayInfoDecodeErrorZ() { CResult_BlindedPayInfoDecodeErrorZ_free(self); }
10327 CResult_BlindedPayInfoDecodeErrorZ& operator=(CResult_BlindedPayInfoDecodeErrorZ&& o) { CResult_BlindedPayInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPayInfoDecodeErrorZ)); return *this; }
10328 LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() { return &self; }
10329 LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() { return &self; }
10330 const LDKCResult_BlindedPayInfoDecodeErrorZ* operator &() const { return &self; }
10331 const LDKCResult_BlindedPayInfoDecodeErrorZ* operator ->() const { return &self; }
10333 class CResult_ThirtyTwoBytesAPIErrorZ {
10335 LDKCResult_ThirtyTwoBytesAPIErrorZ self;
10337 CResult_ThirtyTwoBytesAPIErrorZ(const CResult_ThirtyTwoBytesAPIErrorZ&) = delete;
10338 CResult_ThirtyTwoBytesAPIErrorZ(CResult_ThirtyTwoBytesAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); }
10339 CResult_ThirtyTwoBytesAPIErrorZ(LDKCResult_ThirtyTwoBytesAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); }
10340 operator LDKCResult_ThirtyTwoBytesAPIErrorZ() && { LDKCResult_ThirtyTwoBytesAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ)); return res; }
10341 ~CResult_ThirtyTwoBytesAPIErrorZ() { CResult_ThirtyTwoBytesAPIErrorZ_free(self); }
10342 CResult_ThirtyTwoBytesAPIErrorZ& operator=(CResult_ThirtyTwoBytesAPIErrorZ&& o) { CResult_ThirtyTwoBytesAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesAPIErrorZ)); return *this; }
10343 LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() { return &self; }
10344 LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() { return &self; }
10345 const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator &() const { return &self; }
10346 const LDKCResult_ThirtyTwoBytesAPIErrorZ* operator ->() const { return &self; }
10348 class COption_ChannelShutdownStateZ {
10350 LDKCOption_ChannelShutdownStateZ self;
10352 COption_ChannelShutdownStateZ(const COption_ChannelShutdownStateZ&) = delete;
10353 COption_ChannelShutdownStateZ(COption_ChannelShutdownStateZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); }
10354 COption_ChannelShutdownStateZ(LDKCOption_ChannelShutdownStateZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); }
10355 operator LDKCOption_ChannelShutdownStateZ() && { LDKCOption_ChannelShutdownStateZ res = self; memset(&self, 0, sizeof(LDKCOption_ChannelShutdownStateZ)); return res; }
10356 ~COption_ChannelShutdownStateZ() { COption_ChannelShutdownStateZ_free(self); }
10357 COption_ChannelShutdownStateZ& operator=(COption_ChannelShutdownStateZ&& o) { COption_ChannelShutdownStateZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ChannelShutdownStateZ)); return *this; }
10358 LDKCOption_ChannelShutdownStateZ* operator &() { return &self; }
10359 LDKCOption_ChannelShutdownStateZ* operator ->() { return &self; }
10360 const LDKCOption_ChannelShutdownStateZ* operator &() const { return &self; }
10361 const LDKCOption_ChannelShutdownStateZ* operator ->() const { return &self; }
10363 class CResult_AcceptChannelDecodeErrorZ {
10365 LDKCResult_AcceptChannelDecodeErrorZ self;
10367 CResult_AcceptChannelDecodeErrorZ(const CResult_AcceptChannelDecodeErrorZ&) = delete;
10368 CResult_AcceptChannelDecodeErrorZ(CResult_AcceptChannelDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); }
10369 CResult_AcceptChannelDecodeErrorZ(LDKCResult_AcceptChannelDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); }
10370 operator LDKCResult_AcceptChannelDecodeErrorZ() && { LDKCResult_AcceptChannelDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_AcceptChannelDecodeErrorZ)); return res; }
10371 ~CResult_AcceptChannelDecodeErrorZ() { CResult_AcceptChannelDecodeErrorZ_free(self); }
10372 CResult_AcceptChannelDecodeErrorZ& operator=(CResult_AcceptChannelDecodeErrorZ&& o) { CResult_AcceptChannelDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_AcceptChannelDecodeErrorZ)); return *this; }
10373 LDKCResult_AcceptChannelDecodeErrorZ* operator &() { return &self; }
10374 LDKCResult_AcceptChannelDecodeErrorZ* operator ->() { return &self; }
10375 const LDKCResult_AcceptChannelDecodeErrorZ* operator &() const { return &self; }
10376 const LDKCResult_AcceptChannelDecodeErrorZ* operator ->() const { return &self; }
10378 class CResult_HostnameDecodeErrorZ {
10380 LDKCResult_HostnameDecodeErrorZ self;
10382 CResult_HostnameDecodeErrorZ(const CResult_HostnameDecodeErrorZ&) = delete;
10383 CResult_HostnameDecodeErrorZ(CResult_HostnameDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); }
10384 CResult_HostnameDecodeErrorZ(LDKCResult_HostnameDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); }
10385 operator LDKCResult_HostnameDecodeErrorZ() && { LDKCResult_HostnameDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HostnameDecodeErrorZ)); return res; }
10386 ~CResult_HostnameDecodeErrorZ() { CResult_HostnameDecodeErrorZ_free(self); }
10387 CResult_HostnameDecodeErrorZ& operator=(CResult_HostnameDecodeErrorZ&& o) { CResult_HostnameDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HostnameDecodeErrorZ)); return *this; }
10388 LDKCResult_HostnameDecodeErrorZ* operator &() { return &self; }
10389 LDKCResult_HostnameDecodeErrorZ* operator ->() { return &self; }
10390 const LDKCResult_HostnameDecodeErrorZ* operator &() const { return &self; }
10391 const LDKCResult_HostnameDecodeErrorZ* operator ->() const { return &self; }
10393 class C2Tuple_u64u16Z {
10395 LDKC2Tuple_u64u16Z self;
10397 C2Tuple_u64u16Z(const C2Tuple_u64u16Z&) = delete;
10398 C2Tuple_u64u16Z(C2Tuple_u64u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u16Z)); }
10399 C2Tuple_u64u16Z(LDKC2Tuple_u64u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u16Z)); }
10400 operator LDKC2Tuple_u64u16Z() && { LDKC2Tuple_u64u16Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u16Z)); return res; }
10401 ~C2Tuple_u64u16Z() { C2Tuple_u64u16Z_free(self); }
10402 C2Tuple_u64u16Z& operator=(C2Tuple_u64u16Z&& o) { C2Tuple_u64u16Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u16Z)); return *this; }
10403 LDKC2Tuple_u64u16Z* operator &() { return &self; }
10404 LDKC2Tuple_u64u16Z* operator ->() { return &self; }
10405 const LDKC2Tuple_u64u16Z* operator &() const { return &self; }
10406 const LDKC2Tuple_u64u16Z* operator ->() const { return &self; }
10408 class COption_ThirtyTwoBytesZ {
10410 LDKCOption_ThirtyTwoBytesZ self;
10412 COption_ThirtyTwoBytesZ(const COption_ThirtyTwoBytesZ&) = delete;
10413 COption_ThirtyTwoBytesZ(COption_ThirtyTwoBytesZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); }
10414 COption_ThirtyTwoBytesZ(LDKCOption_ThirtyTwoBytesZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); }
10415 operator LDKCOption_ThirtyTwoBytesZ() && { LDKCOption_ThirtyTwoBytesZ res = self; memset(&self, 0, sizeof(LDKCOption_ThirtyTwoBytesZ)); return res; }
10416 ~COption_ThirtyTwoBytesZ() { COption_ThirtyTwoBytesZ_free(self); }
10417 COption_ThirtyTwoBytesZ& operator=(COption_ThirtyTwoBytesZ&& o) { COption_ThirtyTwoBytesZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ThirtyTwoBytesZ)); return *this; }
10418 LDKCOption_ThirtyTwoBytesZ* operator &() { return &self; }
10419 LDKCOption_ThirtyTwoBytesZ* operator ->() { return &self; }
10420 const LDKCOption_ThirtyTwoBytesZ* operator &() const { return &self; }
10421 const LDKCOption_ThirtyTwoBytesZ* operator ->() const { return &self; }
10427 CVec_u64Z(const CVec_u64Z&) = delete;
10428 CVec_u64Z(CVec_u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_u64Z)); }
10429 CVec_u64Z(LDKCVec_u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_u64Z)); }
10430 operator LDKCVec_u64Z() && { LDKCVec_u64Z res = self; memset(&self, 0, sizeof(LDKCVec_u64Z)); return res; }
10431 ~CVec_u64Z() { CVec_u64Z_free(self); }
10432 CVec_u64Z& operator=(CVec_u64Z&& o) { CVec_u64Z_free(self); self = o.self; memset(&o, 0, sizeof(CVec_u64Z)); return *this; }
10433 LDKCVec_u64Z* operator &() { return &self; }
10434 LDKCVec_u64Z* operator ->() { return &self; }
10435 const LDKCVec_u64Z* operator &() const { return &self; }
10436 const LDKCVec_u64Z* operator ->() const { return &self; }
10438 class CResult_NoneBolt12SemanticErrorZ {
10440 LDKCResult_NoneBolt12SemanticErrorZ self;
10442 CResult_NoneBolt12SemanticErrorZ(const CResult_NoneBolt12SemanticErrorZ&) = delete;
10443 CResult_NoneBolt12SemanticErrorZ(CResult_NoneBolt12SemanticErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); }
10444 CResult_NoneBolt12SemanticErrorZ(LDKCResult_NoneBolt12SemanticErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); }
10445 operator LDKCResult_NoneBolt12SemanticErrorZ() && { LDKCResult_NoneBolt12SemanticErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneBolt12SemanticErrorZ)); return res; }
10446 ~CResult_NoneBolt12SemanticErrorZ() { CResult_NoneBolt12SemanticErrorZ_free(self); }
10447 CResult_NoneBolt12SemanticErrorZ& operator=(CResult_NoneBolt12SemanticErrorZ&& o) { CResult_NoneBolt12SemanticErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneBolt12SemanticErrorZ)); return *this; }
10448 LDKCResult_NoneBolt12SemanticErrorZ* operator &() { return &self; }
10449 LDKCResult_NoneBolt12SemanticErrorZ* operator ->() { return &self; }
10450 const LDKCResult_NoneBolt12SemanticErrorZ* operator &() const { return &self; }
10451 const LDKCResult_NoneBolt12SemanticErrorZ* operator ->() const { return &self; }
10453 class COption_SecretKeyZ {
10455 LDKCOption_SecretKeyZ self;
10457 COption_SecretKeyZ(const COption_SecretKeyZ&) = delete;
10458 COption_SecretKeyZ(COption_SecretKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_SecretKeyZ)); }
10459 COption_SecretKeyZ(LDKCOption_SecretKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_SecretKeyZ)); }
10460 operator LDKCOption_SecretKeyZ() && { LDKCOption_SecretKeyZ res = self; memset(&self, 0, sizeof(LDKCOption_SecretKeyZ)); return res; }
10461 ~COption_SecretKeyZ() { COption_SecretKeyZ_free(self); }
10462 COption_SecretKeyZ& operator=(COption_SecretKeyZ&& o) { COption_SecretKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_SecretKeyZ)); return *this; }
10463 LDKCOption_SecretKeyZ* operator &() { return &self; }
10464 LDKCOption_SecretKeyZ* operator ->() { return &self; }
10465 const LDKCOption_SecretKeyZ* operator &() const { return &self; }
10466 const LDKCOption_SecretKeyZ* operator ->() const { return &self; }
10468 class CResult_C2Tuple_CVec_u8Zu64ZNoneZ {
10470 LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ self;
10472 CResult_C2Tuple_CVec_u8Zu64ZNoneZ(const CResult_C2Tuple_CVec_u8Zu64ZNoneZ&) = delete;
10473 CResult_C2Tuple_CVec_u8Zu64ZNoneZ(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
10474 CResult_C2Tuple_CVec_u8Zu64ZNoneZ(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); }
10475 operator LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ() && { LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return res; }
10476 ~CResult_C2Tuple_CVec_u8Zu64ZNoneZ() { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); }
10477 CResult_C2Tuple_CVec_u8Zu64ZNoneZ& operator=(CResult_C2Tuple_CVec_u8Zu64ZNoneZ&& o) { CResult_C2Tuple_CVec_u8Zu64ZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_C2Tuple_CVec_u8Zu64ZNoneZ)); return *this; }
10478 LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() { return &self; }
10479 LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() { return &self; }
10480 const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator &() const { return &self; }
10481 const LDKCResult_C2Tuple_CVec_u8Zu64ZNoneZ* operator ->() const { return &self; }
10483 class COption_EventZ {
10485 LDKCOption_EventZ self;
10487 COption_EventZ(const COption_EventZ&) = delete;
10488 COption_EventZ(COption_EventZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_EventZ)); }
10489 COption_EventZ(LDKCOption_EventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_EventZ)); }
10490 operator LDKCOption_EventZ() && { LDKCOption_EventZ res = self; memset(&self, 0, sizeof(LDKCOption_EventZ)); return res; }
10491 ~COption_EventZ() { COption_EventZ_free(self); }
10492 COption_EventZ& operator=(COption_EventZ&& o) { COption_EventZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_EventZ)); return *this; }
10493 LDKCOption_EventZ* operator &() { return &self; }
10494 LDKCOption_EventZ* operator ->() { return &self; }
10495 const LDKCOption_EventZ* operator &() const { return &self; }
10496 const LDKCOption_EventZ* operator ->() const { return &self; }
10498 class CResult_ChannelTypeFeaturesDecodeErrorZ {
10500 LDKCResult_ChannelTypeFeaturesDecodeErrorZ self;
10502 CResult_ChannelTypeFeaturesDecodeErrorZ(const CResult_ChannelTypeFeaturesDecodeErrorZ&) = delete;
10503 CResult_ChannelTypeFeaturesDecodeErrorZ(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); }
10504 CResult_ChannelTypeFeaturesDecodeErrorZ(LDKCResult_ChannelTypeFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); }
10505 operator LDKCResult_ChannelTypeFeaturesDecodeErrorZ() && { LDKCResult_ChannelTypeFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ)); return res; }
10506 ~CResult_ChannelTypeFeaturesDecodeErrorZ() { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); }
10507 CResult_ChannelTypeFeaturesDecodeErrorZ& operator=(CResult_ChannelTypeFeaturesDecodeErrorZ&& o) { CResult_ChannelTypeFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelTypeFeaturesDecodeErrorZ)); return *this; }
10508 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() { return &self; }
10509 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() { return &self; }
10510 const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator &() const { return &self; }
10511 const LDKCResult_ChannelTypeFeaturesDecodeErrorZ* operator ->() const { return &self; }
10513 class COption_CVec_SocketAddressZZ {
10515 LDKCOption_CVec_SocketAddressZZ self;
10517 COption_CVec_SocketAddressZZ(const COption_CVec_SocketAddressZZ&) = delete;
10518 COption_CVec_SocketAddressZZ(COption_CVec_SocketAddressZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_SocketAddressZZ)); }
10519 COption_CVec_SocketAddressZZ(LDKCOption_CVec_SocketAddressZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); }
10520 operator LDKCOption_CVec_SocketAddressZZ() && { LDKCOption_CVec_SocketAddressZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_SocketAddressZZ)); return res; }
10521 ~COption_CVec_SocketAddressZZ() { COption_CVec_SocketAddressZZ_free(self); }
10522 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; }
10523 LDKCOption_CVec_SocketAddressZZ* operator &() { return &self; }
10524 LDKCOption_CVec_SocketAddressZZ* operator ->() { return &self; }
10525 const LDKCOption_CVec_SocketAddressZZ* operator &() const { return &self; }
10526 const LDKCOption_CVec_SocketAddressZZ* operator ->() const { return &self; }
10528 class CVec_RouteHintZ {
10530 LDKCVec_RouteHintZ self;
10532 CVec_RouteHintZ(const CVec_RouteHintZ&) = delete;
10533 CVec_RouteHintZ(CVec_RouteHintZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_RouteHintZ)); }
10534 CVec_RouteHintZ(LDKCVec_RouteHintZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_RouteHintZ)); }
10535 operator LDKCVec_RouteHintZ() && { LDKCVec_RouteHintZ res = self; memset(&self, 0, sizeof(LDKCVec_RouteHintZ)); return res; }
10536 ~CVec_RouteHintZ() { CVec_RouteHintZ_free(self); }
10537 CVec_RouteHintZ& operator=(CVec_RouteHintZ&& o) { CVec_RouteHintZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_RouteHintZ)); return *this; }
10538 LDKCVec_RouteHintZ* operator &() { return &self; }
10539 LDKCVec_RouteHintZ* operator ->() { return &self; }
10540 const LDKCVec_RouteHintZ* operator &() const { return &self; }
10541 const LDKCVec_RouteHintZ* operator ->() const { return &self; }
10543 class COption_u16Z {
10545 LDKCOption_u16Z self;
10547 COption_u16Z(const COption_u16Z&) = delete;
10548 COption_u16Z(COption_u16Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_u16Z)); }
10549 COption_u16Z(LDKCOption_u16Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_u16Z)); }
10550 operator LDKCOption_u16Z() && { LDKCOption_u16Z res = self; memset(&self, 0, sizeof(LDKCOption_u16Z)); return res; }
10551 ~COption_u16Z() { COption_u16Z_free(self); }
10552 COption_u16Z& operator=(COption_u16Z&& o) { COption_u16Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_u16Z)); return *this; }
10553 LDKCOption_u16Z* operator &() { return &self; }
10554 LDKCOption_u16Z* operator ->() { return &self; }
10555 const LDKCOption_u16Z* operator &() const { return &self; }
10556 const LDKCOption_u16Z* operator ->() const { return &self; }
10558 class COption_PaymentFailureReasonZ {
10560 LDKCOption_PaymentFailureReasonZ self;
10562 COption_PaymentFailureReasonZ(const COption_PaymentFailureReasonZ&) = delete;
10563 COption_PaymentFailureReasonZ(COption_PaymentFailureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); }
10564 COption_PaymentFailureReasonZ(LDKCOption_PaymentFailureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); }
10565 operator LDKCOption_PaymentFailureReasonZ() && { LDKCOption_PaymentFailureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_PaymentFailureReasonZ)); return res; }
10566 ~COption_PaymentFailureReasonZ() { COption_PaymentFailureReasonZ_free(self); }
10567 COption_PaymentFailureReasonZ& operator=(COption_PaymentFailureReasonZ&& o) { COption_PaymentFailureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_PaymentFailureReasonZ)); return *this; }
10568 LDKCOption_PaymentFailureReasonZ* operator &() { return &self; }
10569 LDKCOption_PaymentFailureReasonZ* operator ->() { return &self; }
10570 const LDKCOption_PaymentFailureReasonZ* operator &() const { return &self; }
10571 const LDKCOption_PaymentFailureReasonZ* operator ->() const { return &self; }
10573 class CResult_ECDSASignatureNoneZ {
10575 LDKCResult_ECDSASignatureNoneZ self;
10577 CResult_ECDSASignatureNoneZ(const CResult_ECDSASignatureNoneZ&) = delete;
10578 CResult_ECDSASignatureNoneZ(CResult_ECDSASignatureNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); }
10579 CResult_ECDSASignatureNoneZ(LDKCResult_ECDSASignatureNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); }
10580 operator LDKCResult_ECDSASignatureNoneZ() && { LDKCResult_ECDSASignatureNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_ECDSASignatureNoneZ)); return res; }
10581 ~CResult_ECDSASignatureNoneZ() { CResult_ECDSASignatureNoneZ_free(self); }
10582 CResult_ECDSASignatureNoneZ& operator=(CResult_ECDSASignatureNoneZ&& o) { CResult_ECDSASignatureNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ECDSASignatureNoneZ)); return *this; }
10583 LDKCResult_ECDSASignatureNoneZ* operator &() { return &self; }
10584 LDKCResult_ECDSASignatureNoneZ* operator ->() { return &self; }
10585 const LDKCResult_ECDSASignatureNoneZ* operator &() const { return &self; }
10586 const LDKCResult_ECDSASignatureNoneZ* operator ->() const { return &self; }
10588 class CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ {
10590 LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ self;
10592 CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(const CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&) = delete;
10593 CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
10594 CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); }
10595 operator LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() && { LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return res; }
10596 ~CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ() { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); }
10597 CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ& operator=(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ&& o) { CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ)); return *this; }
10598 LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() { return &self; }
10599 LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() { return &self; }
10600 const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator &() const { return &self; }
10601 const LDKCResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ* operator ->() const { return &self; }
10603 class CVec_WitnessZ {
10605 LDKCVec_WitnessZ self;
10607 CVec_WitnessZ(const CVec_WitnessZ&) = delete;
10608 CVec_WitnessZ(CVec_WitnessZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_WitnessZ)); }
10609 CVec_WitnessZ(LDKCVec_WitnessZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_WitnessZ)); }
10610 operator LDKCVec_WitnessZ() && { LDKCVec_WitnessZ res = self; memset(&self, 0, sizeof(LDKCVec_WitnessZ)); return res; }
10611 ~CVec_WitnessZ() { CVec_WitnessZ_free(self); }
10612 CVec_WitnessZ& operator=(CVec_WitnessZ&& o) { CVec_WitnessZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_WitnessZ)); return *this; }
10613 LDKCVec_WitnessZ* operator &() { return &self; }
10614 LDKCVec_WitnessZ* operator ->() { return &self; }
10615 const LDKCVec_WitnessZ* operator &() const { return &self; }
10616 const LDKCVec_WitnessZ* operator ->() const { return &self; }
10618 class CResult_BlindedTailDecodeErrorZ {
10620 LDKCResult_BlindedTailDecodeErrorZ self;
10622 CResult_BlindedTailDecodeErrorZ(const CResult_BlindedTailDecodeErrorZ&) = delete;
10623 CResult_BlindedTailDecodeErrorZ(CResult_BlindedTailDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); }
10624 CResult_BlindedTailDecodeErrorZ(LDKCResult_BlindedTailDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); }
10625 operator LDKCResult_BlindedTailDecodeErrorZ() && { LDKCResult_BlindedTailDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedTailDecodeErrorZ)); return res; }
10626 ~CResult_BlindedTailDecodeErrorZ() { CResult_BlindedTailDecodeErrorZ_free(self); }
10627 CResult_BlindedTailDecodeErrorZ& operator=(CResult_BlindedTailDecodeErrorZ&& o) { CResult_BlindedTailDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedTailDecodeErrorZ)); return *this; }
10628 LDKCResult_BlindedTailDecodeErrorZ* operator &() { return &self; }
10629 LDKCResult_BlindedTailDecodeErrorZ* operator ->() { return &self; }
10630 const LDKCResult_BlindedTailDecodeErrorZ* operator &() const { return &self; }
10631 const LDKCResult_BlindedTailDecodeErrorZ* operator ->() const { return &self; }
10633 class CResult_SocketAddressSocketAddressParseErrorZ {
10635 LDKCResult_SocketAddressSocketAddressParseErrorZ self;
10637 CResult_SocketAddressSocketAddressParseErrorZ(const CResult_SocketAddressSocketAddressParseErrorZ&) = delete;
10638 CResult_SocketAddressSocketAddressParseErrorZ(CResult_SocketAddressSocketAddressParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); }
10639 CResult_SocketAddressSocketAddressParseErrorZ(LDKCResult_SocketAddressSocketAddressParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); }
10640 operator LDKCResult_SocketAddressSocketAddressParseErrorZ() && { LDKCResult_SocketAddressSocketAddressParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ)); return res; }
10641 ~CResult_SocketAddressSocketAddressParseErrorZ() { CResult_SocketAddressSocketAddressParseErrorZ_free(self); }
10642 CResult_SocketAddressSocketAddressParseErrorZ& operator=(CResult_SocketAddressSocketAddressParseErrorZ&& o) { CResult_SocketAddressSocketAddressParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SocketAddressSocketAddressParseErrorZ)); return *this; }
10643 LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() { return &self; }
10644 LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() { return &self; }
10645 const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator &() const { return &self; }
10646 const LDKCResult_SocketAddressSocketAddressParseErrorZ* operator ->() const { return &self; }
10648 class COption_C2Tuple_u64u16ZZ {
10650 LDKCOption_C2Tuple_u64u16ZZ self;
10652 COption_C2Tuple_u64u16ZZ(const COption_C2Tuple_u64u16ZZ&) = delete;
10653 COption_C2Tuple_u64u16ZZ(COption_C2Tuple_u64u16ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_C2Tuple_u64u16ZZ)); }
10654 COption_C2Tuple_u64u16ZZ(LDKCOption_C2Tuple_u64u16ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); }
10655 operator LDKCOption_C2Tuple_u64u16ZZ() && { LDKCOption_C2Tuple_u64u16ZZ res = self; memset(&self, 0, sizeof(LDKCOption_C2Tuple_u64u16ZZ)); return res; }
10656 ~COption_C2Tuple_u64u16ZZ() { COption_C2Tuple_u64u16ZZ_free(self); }
10657 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; }
10658 LDKCOption_C2Tuple_u64u16ZZ* operator &() { return &self; }
10659 LDKCOption_C2Tuple_u64u16ZZ* operator ->() { return &self; }
10660 const LDKCOption_C2Tuple_u64u16ZZ* operator &() const { return &self; }
10661 const LDKCOption_C2Tuple_u64u16ZZ* operator ->() const { return &self; }
10663 class CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ {
10665 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ self;
10667 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(const CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&) = delete;
10668 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
10669 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); }
10670 operator LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() && { LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return res; }
10671 ~CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ() { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); }
10672 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ& operator=(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ&& o) { CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ)); return *this; }
10673 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() { return &self; }
10674 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() { return &self; }
10675 const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator &() const { return &self; }
10676 const LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* operator ->() const { return &self; }
10678 class CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ {
10680 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ self;
10682 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&) = delete;
10683 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
10684 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); }
10685 operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ)); return res; }
10686 ~CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(self); }
10687 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; }
10688 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() { return &self; }
10689 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() { return &self; }
10690 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator &() const { return &self; }
10691 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* operator ->() const { return &self; }
10693 class CResult_ChannelDerivationParametersDecodeErrorZ {
10695 LDKCResult_ChannelDerivationParametersDecodeErrorZ self;
10697 CResult_ChannelDerivationParametersDecodeErrorZ(const CResult_ChannelDerivationParametersDecodeErrorZ&) = delete;
10698 CResult_ChannelDerivationParametersDecodeErrorZ(CResult_ChannelDerivationParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); }
10699 CResult_ChannelDerivationParametersDecodeErrorZ(LDKCResult_ChannelDerivationParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); }
10700 operator LDKCResult_ChannelDerivationParametersDecodeErrorZ() && { LDKCResult_ChannelDerivationParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ)); return res; }
10701 ~CResult_ChannelDerivationParametersDecodeErrorZ() { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); }
10702 CResult_ChannelDerivationParametersDecodeErrorZ& operator=(CResult_ChannelDerivationParametersDecodeErrorZ&& o) { CResult_ChannelDerivationParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDerivationParametersDecodeErrorZ)); return *this; }
10703 LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() { return &self; }
10704 LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() { return &self; }
10705 const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator &() const { return &self; }
10706 const LDKCResult_ChannelDerivationParametersDecodeErrorZ* operator ->() const { return &self; }
10708 class CResult_PaymentConstraintsDecodeErrorZ {
10710 LDKCResult_PaymentConstraintsDecodeErrorZ self;
10712 CResult_PaymentConstraintsDecodeErrorZ(const CResult_PaymentConstraintsDecodeErrorZ&) = delete;
10713 CResult_PaymentConstraintsDecodeErrorZ(CResult_PaymentConstraintsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); }
10714 CResult_PaymentConstraintsDecodeErrorZ(LDKCResult_PaymentConstraintsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); }
10715 operator LDKCResult_PaymentConstraintsDecodeErrorZ() && { LDKCResult_PaymentConstraintsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ)); return res; }
10716 ~CResult_PaymentConstraintsDecodeErrorZ() { CResult_PaymentConstraintsDecodeErrorZ_free(self); }
10717 CResult_PaymentConstraintsDecodeErrorZ& operator=(CResult_PaymentConstraintsDecodeErrorZ&& o) { CResult_PaymentConstraintsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PaymentConstraintsDecodeErrorZ)); return *this; }
10718 LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() { return &self; }
10719 LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() { return &self; }
10720 const LDKCResult_PaymentConstraintsDecodeErrorZ* operator &() const { return &self; }
10721 const LDKCResult_PaymentConstraintsDecodeErrorZ* operator ->() const { return &self; }
10723 class CResult_OnionMessagePathNoneZ {
10725 LDKCResult_OnionMessagePathNoneZ self;
10727 CResult_OnionMessagePathNoneZ(const CResult_OnionMessagePathNoneZ&) = delete;
10728 CResult_OnionMessagePathNoneZ(CResult_OnionMessagePathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); }
10729 CResult_OnionMessagePathNoneZ(LDKCResult_OnionMessagePathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); }
10730 operator LDKCResult_OnionMessagePathNoneZ() && { LDKCResult_OnionMessagePathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_OnionMessagePathNoneZ)); return res; }
10731 ~CResult_OnionMessagePathNoneZ() { CResult_OnionMessagePathNoneZ_free(self); }
10732 CResult_OnionMessagePathNoneZ& operator=(CResult_OnionMessagePathNoneZ&& o) { CResult_OnionMessagePathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OnionMessagePathNoneZ)); return *this; }
10733 LDKCResult_OnionMessagePathNoneZ* operator &() { return &self; }
10734 LDKCResult_OnionMessagePathNoneZ* operator ->() { return &self; }
10735 const LDKCResult_OnionMessagePathNoneZ* operator &() const { return &self; }
10736 const LDKCResult_OnionMessagePathNoneZ* operator ->() const { return &self; }
10738 class C2Tuple_u32CVec_u8ZZ {
10740 LDKC2Tuple_u32CVec_u8ZZ self;
10742 C2Tuple_u32CVec_u8ZZ(const C2Tuple_u32CVec_u8ZZ&) = delete;
10743 C2Tuple_u32CVec_u8ZZ(C2Tuple_u32CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32CVec_u8ZZ)); }
10744 C2Tuple_u32CVec_u8ZZ(LDKC2Tuple_u32CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); }
10745 operator LDKC2Tuple_u32CVec_u8ZZ() && { LDKC2Tuple_u32CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32CVec_u8ZZ)); return res; }
10746 ~C2Tuple_u32CVec_u8ZZ() { C2Tuple_u32CVec_u8ZZ_free(self); }
10747 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; }
10748 LDKC2Tuple_u32CVec_u8ZZ* operator &() { return &self; }
10749 LDKC2Tuple_u32CVec_u8ZZ* operator ->() { return &self; }
10750 const LDKC2Tuple_u32CVec_u8ZZ* operator &() const { return &self; }
10751 const LDKC2Tuple_u32CVec_u8ZZ* operator ->() const { return &self; }
10753 class CVec_C2Tuple_PublicKeyTypeZZ {
10755 LDKCVec_C2Tuple_PublicKeyTypeZZ self;
10757 CVec_C2Tuple_PublicKeyTypeZZ(const CVec_C2Tuple_PublicKeyTypeZZ&) = delete;
10758 CVec_C2Tuple_PublicKeyTypeZZ(CVec_C2Tuple_PublicKeyTypeZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_PublicKeyTypeZZ)); }
10759 CVec_C2Tuple_PublicKeyTypeZZ(LDKCVec_C2Tuple_PublicKeyTypeZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); }
10760 operator LDKCVec_C2Tuple_PublicKeyTypeZZ() && { LDKCVec_C2Tuple_PublicKeyTypeZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ)); return res; }
10761 ~CVec_C2Tuple_PublicKeyTypeZZ() { CVec_C2Tuple_PublicKeyTypeZZ_free(self); }
10762 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; }
10763 LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() { return &self; }
10764 LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() { return &self; }
10765 const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator &() const { return &self; }
10766 const LDKCVec_C2Tuple_PublicKeyTypeZZ* operator ->() const { return &self; }
10768 class CResult_RefundBolt12ParseErrorZ {
10770 LDKCResult_RefundBolt12ParseErrorZ self;
10772 CResult_RefundBolt12ParseErrorZ(const CResult_RefundBolt12ParseErrorZ&) = delete;
10773 CResult_RefundBolt12ParseErrorZ(CResult_RefundBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); }
10774 CResult_RefundBolt12ParseErrorZ(LDKCResult_RefundBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); }
10775 operator LDKCResult_RefundBolt12ParseErrorZ() && { LDKCResult_RefundBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RefundBolt12ParseErrorZ)); return res; }
10776 ~CResult_RefundBolt12ParseErrorZ() { CResult_RefundBolt12ParseErrorZ_free(self); }
10777 CResult_RefundBolt12ParseErrorZ& operator=(CResult_RefundBolt12ParseErrorZ&& o) { CResult_RefundBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RefundBolt12ParseErrorZ)); return *this; }
10778 LDKCResult_RefundBolt12ParseErrorZ* operator &() { return &self; }
10779 LDKCResult_RefundBolt12ParseErrorZ* operator ->() { return &self; }
10780 const LDKCResult_RefundBolt12ParseErrorZ* operator &() const { return &self; }
10781 const LDKCResult_RefundBolt12ParseErrorZ* operator ->() const { return &self; }
10783 class C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ {
10785 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ self;
10787 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(const C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&) = delete;
10788 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10789 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); }
10790 operator LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() && { LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ res = self; memset(&self, 0, sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)); return res; }
10791 ~C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ() { C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(self); }
10792 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; }
10793 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() { return &self; }
10794 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() { return &self; }
10795 const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator &() const { return &self; }
10796 const LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* operator ->() const { return &self; }
10798 class CVec_C2Tuple_u64CVec_u8ZZZ {
10800 LDKCVec_C2Tuple_u64CVec_u8ZZZ self;
10802 CVec_C2Tuple_u64CVec_u8ZZZ(const CVec_C2Tuple_u64CVec_u8ZZZ&) = delete;
10803 CVec_C2Tuple_u64CVec_u8ZZZ(CVec_C2Tuple_u64CVec_u8ZZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_u64CVec_u8ZZZ)); }
10804 CVec_C2Tuple_u64CVec_u8ZZZ(LDKCVec_C2Tuple_u64CVec_u8ZZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); }
10805 operator LDKCVec_C2Tuple_u64CVec_u8ZZZ() && { LDKCVec_C2Tuple_u64CVec_u8ZZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_u64CVec_u8ZZZ)); return res; }
10806 ~CVec_C2Tuple_u64CVec_u8ZZZ() { CVec_C2Tuple_u64CVec_u8ZZZ_free(self); }
10807 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; }
10808 LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() { return &self; }
10809 LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() { return &self; }
10810 const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator &() const { return &self; }
10811 const LDKCVec_C2Tuple_u64CVec_u8ZZZ* operator ->() const { return &self; }
10813 class CResult_u32GraphSyncErrorZ {
10815 LDKCResult_u32GraphSyncErrorZ self;
10817 CResult_u32GraphSyncErrorZ(const CResult_u32GraphSyncErrorZ&) = delete;
10818 CResult_u32GraphSyncErrorZ(CResult_u32GraphSyncErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); }
10819 CResult_u32GraphSyncErrorZ(LDKCResult_u32GraphSyncErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); }
10820 operator LDKCResult_u32GraphSyncErrorZ() && { LDKCResult_u32GraphSyncErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_u32GraphSyncErrorZ)); return res; }
10821 ~CResult_u32GraphSyncErrorZ() { CResult_u32GraphSyncErrorZ_free(self); }
10822 CResult_u32GraphSyncErrorZ& operator=(CResult_u32GraphSyncErrorZ&& o) { CResult_u32GraphSyncErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_u32GraphSyncErrorZ)); return *this; }
10823 LDKCResult_u32GraphSyncErrorZ* operator &() { return &self; }
10824 LDKCResult_u32GraphSyncErrorZ* operator ->() { return &self; }
10825 const LDKCResult_u32GraphSyncErrorZ* operator &() const { return &self; }
10826 const LDKCResult_u32GraphSyncErrorZ* operator ->() const { return &self; }
10828 class CVec_PhantomRouteHintsZ {
10830 LDKCVec_PhantomRouteHintsZ self;
10832 CVec_PhantomRouteHintsZ(const CVec_PhantomRouteHintsZ&) = delete;
10833 CVec_PhantomRouteHintsZ(CVec_PhantomRouteHintsZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); }
10834 CVec_PhantomRouteHintsZ(LDKCVec_PhantomRouteHintsZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); }
10835 operator LDKCVec_PhantomRouteHintsZ() && { LDKCVec_PhantomRouteHintsZ res = self; memset(&self, 0, sizeof(LDKCVec_PhantomRouteHintsZ)); return res; }
10836 ~CVec_PhantomRouteHintsZ() { CVec_PhantomRouteHintsZ_free(self); }
10837 CVec_PhantomRouteHintsZ& operator=(CVec_PhantomRouteHintsZ&& o) { CVec_PhantomRouteHintsZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PhantomRouteHintsZ)); return *this; }
10838 LDKCVec_PhantomRouteHintsZ* operator &() { return &self; }
10839 LDKCVec_PhantomRouteHintsZ* operator ->() { return &self; }
10840 const LDKCVec_PhantomRouteHintsZ* operator &() const { return &self; }
10841 const LDKCVec_PhantomRouteHintsZ* operator ->() const { return &self; }
10843 class CResult_NoneAPIErrorZ {
10845 LDKCResult_NoneAPIErrorZ self;
10847 CResult_NoneAPIErrorZ(const CResult_NoneAPIErrorZ&) = delete;
10848 CResult_NoneAPIErrorZ(CResult_NoneAPIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); }
10849 CResult_NoneAPIErrorZ(LDKCResult_NoneAPIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); }
10850 operator LDKCResult_NoneAPIErrorZ() && { LDKCResult_NoneAPIErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneAPIErrorZ)); return res; }
10851 ~CResult_NoneAPIErrorZ() { CResult_NoneAPIErrorZ_free(self); }
10852 CResult_NoneAPIErrorZ& operator=(CResult_NoneAPIErrorZ&& o) { CResult_NoneAPIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneAPIErrorZ)); return *this; }
10853 LDKCResult_NoneAPIErrorZ* operator &() { return &self; }
10854 LDKCResult_NoneAPIErrorZ* operator ->() { return &self; }
10855 const LDKCResult_NoneAPIErrorZ* operator &() const { return &self; }
10856 const LDKCResult_NoneAPIErrorZ* operator ->() const { return &self; }
10858 class CResult_Bolt12InvoiceFeaturesDecodeErrorZ {
10860 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ self;
10862 CResult_Bolt12InvoiceFeaturesDecodeErrorZ(const CResult_Bolt12InvoiceFeaturesDecodeErrorZ&) = delete;
10863 CResult_Bolt12InvoiceFeaturesDecodeErrorZ(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10864 CResult_Bolt12InvoiceFeaturesDecodeErrorZ(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); }
10865 operator LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ() && { LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return res; }
10866 ~CResult_Bolt12InvoiceFeaturesDecodeErrorZ() { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); }
10867 CResult_Bolt12InvoiceFeaturesDecodeErrorZ& operator=(CResult_Bolt12InvoiceFeaturesDecodeErrorZ&& o) { CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_Bolt12InvoiceFeaturesDecodeErrorZ)); return *this; }
10868 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() { return &self; }
10869 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() { return &self; }
10870 const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator &() const { return &self; }
10871 const LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* operator ->() const { return &self; }
10873 class COption_f64Z {
10875 LDKCOption_f64Z self;
10877 COption_f64Z(const COption_f64Z&) = delete;
10878 COption_f64Z(COption_f64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_f64Z)); }
10879 COption_f64Z(LDKCOption_f64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_f64Z)); }
10880 operator LDKCOption_f64Z() && { LDKCOption_f64Z res = self; memset(&self, 0, sizeof(LDKCOption_f64Z)); return res; }
10881 ~COption_f64Z() { COption_f64Z_free(self); }
10882 COption_f64Z& operator=(COption_f64Z&& o) { COption_f64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_f64Z)); return *this; }
10883 LDKCOption_f64Z* operator &() { return &self; }
10884 LDKCOption_f64Z* operator ->() { return &self; }
10885 const LDKCOption_f64Z* operator &() const { return &self; }
10886 const LDKCOption_f64Z* operator ->() const { return &self; }
10888 class CResult_ChannelDetailsDecodeErrorZ {
10890 LDKCResult_ChannelDetailsDecodeErrorZ self;
10892 CResult_ChannelDetailsDecodeErrorZ(const CResult_ChannelDetailsDecodeErrorZ&) = delete;
10893 CResult_ChannelDetailsDecodeErrorZ(CResult_ChannelDetailsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); }
10894 CResult_ChannelDetailsDecodeErrorZ(LDKCResult_ChannelDetailsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); }
10895 operator LDKCResult_ChannelDetailsDecodeErrorZ() && { LDKCResult_ChannelDetailsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelDetailsDecodeErrorZ)); return res; }
10896 ~CResult_ChannelDetailsDecodeErrorZ() { CResult_ChannelDetailsDecodeErrorZ_free(self); }
10897 CResult_ChannelDetailsDecodeErrorZ& operator=(CResult_ChannelDetailsDecodeErrorZ&& o) { CResult_ChannelDetailsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelDetailsDecodeErrorZ)); return *this; }
10898 LDKCResult_ChannelDetailsDecodeErrorZ* operator &() { return &self; }
10899 LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() { return &self; }
10900 const LDKCResult_ChannelDetailsDecodeErrorZ* operator &() const { return &self; }
10901 const LDKCResult_ChannelDetailsDecodeErrorZ* operator ->() const { return &self; }
10903 class CVec_PublicKeyZ {
10905 LDKCVec_PublicKeyZ self;
10907 CVec_PublicKeyZ(const CVec_PublicKeyZ&) = delete;
10908 CVec_PublicKeyZ(CVec_PublicKeyZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PublicKeyZ)); }
10909 CVec_PublicKeyZ(LDKCVec_PublicKeyZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PublicKeyZ)); }
10910 operator LDKCVec_PublicKeyZ() && { LDKCVec_PublicKeyZ res = self; memset(&self, 0, sizeof(LDKCVec_PublicKeyZ)); return res; }
10911 ~CVec_PublicKeyZ() { CVec_PublicKeyZ_free(self); }
10912 CVec_PublicKeyZ& operator=(CVec_PublicKeyZ&& o) { CVec_PublicKeyZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PublicKeyZ)); return *this; }
10913 LDKCVec_PublicKeyZ* operator &() { return &self; }
10914 LDKCVec_PublicKeyZ* operator ->() { return &self; }
10915 const LDKCVec_PublicKeyZ* operator &() const { return &self; }
10916 const LDKCVec_PublicKeyZ* operator ->() const { return &self; }
10918 class C2Tuple_CVec_u8Zu64Z {
10920 LDKC2Tuple_CVec_u8Zu64Z self;
10922 C2Tuple_CVec_u8Zu64Z(const C2Tuple_CVec_u8Zu64Z&) = delete;
10923 C2Tuple_CVec_u8Zu64Z(C2Tuple_CVec_u8Zu64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); }
10924 C2Tuple_CVec_u8Zu64Z(LDKC2Tuple_CVec_u8Zu64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); }
10925 operator LDKC2Tuple_CVec_u8Zu64Z() && { LDKC2Tuple_CVec_u8Zu64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_CVec_u8Zu64Z)); return res; }
10926 ~C2Tuple_CVec_u8Zu64Z() { C2Tuple_CVec_u8Zu64Z_free(self); }
10927 C2Tuple_CVec_u8Zu64Z& operator=(C2Tuple_CVec_u8Zu64Z&& o) { C2Tuple_CVec_u8Zu64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_CVec_u8Zu64Z)); return *this; }
10928 LDKC2Tuple_CVec_u8Zu64Z* operator &() { return &self; }
10929 LDKC2Tuple_CVec_u8Zu64Z* operator ->() { return &self; }
10930 const LDKC2Tuple_CVec_u8Zu64Z* operator &() const { return &self; }
10931 const LDKC2Tuple_CVec_u8Zu64Z* operator ->() const { return &self; }
10933 class CVec_C2Tuple_usizeTransactionZZ {
10935 LDKCVec_C2Tuple_usizeTransactionZZ self;
10937 CVec_C2Tuple_usizeTransactionZZ(const CVec_C2Tuple_usizeTransactionZZ&) = delete;
10938 CVec_C2Tuple_usizeTransactionZZ(CVec_C2Tuple_usizeTransactionZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_usizeTransactionZZ)); }
10939 CVec_C2Tuple_usizeTransactionZZ(LDKCVec_C2Tuple_usizeTransactionZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); }
10940 operator LDKCVec_C2Tuple_usizeTransactionZZ() && { LDKCVec_C2Tuple_usizeTransactionZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_usizeTransactionZZ)); return res; }
10941 ~CVec_C2Tuple_usizeTransactionZZ() { CVec_C2Tuple_usizeTransactionZZ_free(self); }
10942 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; }
10943 LDKCVec_C2Tuple_usizeTransactionZZ* operator &() { return &self; }
10944 LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() { return &self; }
10945 const LDKCVec_C2Tuple_usizeTransactionZZ* operator &() const { return &self; }
10946 const LDKCVec_C2Tuple_usizeTransactionZZ* operator ->() const { return &self; }
10948 class CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ {
10950 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ self;
10952 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(const CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&) = delete;
10953 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10954 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); }
10955 operator LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() && { LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ res = self; memset(&self, 0, sizeof(LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ)); return res; }
10956 ~CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ() { CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(self); }
10957 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; }
10958 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() { return &self; }
10959 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() { return &self; }
10960 const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator &() const { return &self; }
10961 const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ* operator ->() const { return &self; }
10963 class CResult_PendingHTLCRoutingDecodeErrorZ {
10965 LDKCResult_PendingHTLCRoutingDecodeErrorZ self;
10967 CResult_PendingHTLCRoutingDecodeErrorZ(const CResult_PendingHTLCRoutingDecodeErrorZ&) = delete;
10968 CResult_PendingHTLCRoutingDecodeErrorZ(CResult_PendingHTLCRoutingDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); }
10969 CResult_PendingHTLCRoutingDecodeErrorZ(LDKCResult_PendingHTLCRoutingDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); }
10970 operator LDKCResult_PendingHTLCRoutingDecodeErrorZ() && { LDKCResult_PendingHTLCRoutingDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_PendingHTLCRoutingDecodeErrorZ)); return res; }
10971 ~CResult_PendingHTLCRoutingDecodeErrorZ() { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); }
10972 CResult_PendingHTLCRoutingDecodeErrorZ& operator=(CResult_PendingHTLCRoutingDecodeErrorZ&& o) { CResult_PendingHTLCRoutingDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_PendingHTLCRoutingDecodeErrorZ)); return *this; }
10973 LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() { return &self; }
10974 LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() { return &self; }
10975 const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator &() const { return &self; }
10976 const LDKCResult_PendingHTLCRoutingDecodeErrorZ* operator ->() const { return &self; }
10978 class C2Tuple_u64u64Z {
10980 LDKC2Tuple_u64u64Z self;
10982 C2Tuple_u64u64Z(const C2Tuple_u64u64Z&) = delete;
10983 C2Tuple_u64u64Z(C2Tuple_u64u64Z&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64u64Z)); }
10984 C2Tuple_u64u64Z(LDKC2Tuple_u64u64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64u64Z)); }
10985 operator LDKC2Tuple_u64u64Z() && { LDKC2Tuple_u64u64Z res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64u64Z)); return res; }
10986 ~C2Tuple_u64u64Z() { C2Tuple_u64u64Z_free(self); }
10987 C2Tuple_u64u64Z& operator=(C2Tuple_u64u64Z&& o) { C2Tuple_u64u64Z_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u64u64Z)); return *this; }
10988 LDKC2Tuple_u64u64Z* operator &() { return &self; }
10989 LDKC2Tuple_u64u64Z* operator ->() { return &self; }
10990 const LDKC2Tuple_u64u64Z* operator &() const { return &self; }
10991 const LDKC2Tuple_u64u64Z* operator ->() const { return &self; }
10993 class CResult_TxRemoveInputDecodeErrorZ {
10995 LDKCResult_TxRemoveInputDecodeErrorZ self;
10997 CResult_TxRemoveInputDecodeErrorZ(const CResult_TxRemoveInputDecodeErrorZ&) = delete;
10998 CResult_TxRemoveInputDecodeErrorZ(CResult_TxRemoveInputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); }
10999 CResult_TxRemoveInputDecodeErrorZ(LDKCResult_TxRemoveInputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); }
11000 operator LDKCResult_TxRemoveInputDecodeErrorZ() && { LDKCResult_TxRemoveInputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxRemoveInputDecodeErrorZ)); return res; }
11001 ~CResult_TxRemoveInputDecodeErrorZ() { CResult_TxRemoveInputDecodeErrorZ_free(self); }
11002 CResult_TxRemoveInputDecodeErrorZ& operator=(CResult_TxRemoveInputDecodeErrorZ&& o) { CResult_TxRemoveInputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxRemoveInputDecodeErrorZ)); return *this; }
11003 LDKCResult_TxRemoveInputDecodeErrorZ* operator &() { return &self; }
11004 LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() { return &self; }
11005 const LDKCResult_TxRemoveInputDecodeErrorZ* operator &() const { return &self; }
11006 const LDKCResult_TxRemoveInputDecodeErrorZ* operator ->() const { return &self; }
11008 class CResult_OffersMessageDecodeErrorZ {
11010 LDKCResult_OffersMessageDecodeErrorZ self;
11012 CResult_OffersMessageDecodeErrorZ(const CResult_OffersMessageDecodeErrorZ&) = delete;
11013 CResult_OffersMessageDecodeErrorZ(CResult_OffersMessageDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); }
11014 CResult_OffersMessageDecodeErrorZ(LDKCResult_OffersMessageDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); }
11015 operator LDKCResult_OffersMessageDecodeErrorZ() && { LDKCResult_OffersMessageDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OffersMessageDecodeErrorZ)); return res; }
11016 ~CResult_OffersMessageDecodeErrorZ() { CResult_OffersMessageDecodeErrorZ_free(self); }
11017 CResult_OffersMessageDecodeErrorZ& operator=(CResult_OffersMessageDecodeErrorZ&& o) { CResult_OffersMessageDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OffersMessageDecodeErrorZ)); return *this; }
11018 LDKCResult_OffersMessageDecodeErrorZ* operator &() { return &self; }
11019 LDKCResult_OffersMessageDecodeErrorZ* operator ->() { return &self; }
11020 const LDKCResult_OffersMessageDecodeErrorZ* operator &() const { return &self; }
11021 const LDKCResult_OffersMessageDecodeErrorZ* operator ->() const { return &self; }
11023 class CResult_CounterpartyChannelTransactionParametersDecodeErrorZ {
11025 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ self;
11027 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(const CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&) = delete;
11028 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
11029 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); }
11030 operator LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ() && { LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return res; }
11031 ~CResult_CounterpartyChannelTransactionParametersDecodeErrorZ() { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); }
11032 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ& operator=(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ&& o) { CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyChannelTransactionParametersDecodeErrorZ)); return *this; }
11033 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() { return &self; }
11034 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() { return &self; }
11035 const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator &() const { return &self; }
11036 const LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* operator ->() const { return &self; }
11038 class CResult_RecipientOnionFieldsDecodeErrorZ {
11040 LDKCResult_RecipientOnionFieldsDecodeErrorZ self;
11042 CResult_RecipientOnionFieldsDecodeErrorZ(const CResult_RecipientOnionFieldsDecodeErrorZ&) = delete;
11043 CResult_RecipientOnionFieldsDecodeErrorZ(CResult_RecipientOnionFieldsDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); }
11044 CResult_RecipientOnionFieldsDecodeErrorZ(LDKCResult_RecipientOnionFieldsDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); }
11045 operator LDKCResult_RecipientOnionFieldsDecodeErrorZ() && { LDKCResult_RecipientOnionFieldsDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ)); return res; }
11046 ~CResult_RecipientOnionFieldsDecodeErrorZ() { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); }
11047 CResult_RecipientOnionFieldsDecodeErrorZ& operator=(CResult_RecipientOnionFieldsDecodeErrorZ&& o) { CResult_RecipientOnionFieldsDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RecipientOnionFieldsDecodeErrorZ)); return *this; }
11048 LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() { return &self; }
11049 LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() { return &self; }
11050 const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator &() const { return &self; }
11051 const LDKCResult_RecipientOnionFieldsDecodeErrorZ* operator ->() const { return &self; }
11053 class C2Tuple_u32TxOutZ {
11055 LDKC2Tuple_u32TxOutZ self;
11057 C2Tuple_u32TxOutZ(const C2Tuple_u32TxOutZ&) = delete;
11058 C2Tuple_u32TxOutZ(C2Tuple_u32TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); }
11059 C2Tuple_u32TxOutZ(LDKC2Tuple_u32TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); }
11060 operator LDKC2Tuple_u32TxOutZ() && { LDKC2Tuple_u32TxOutZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u32TxOutZ)); return res; }
11061 ~C2Tuple_u32TxOutZ() { C2Tuple_u32TxOutZ_free(self); }
11062 C2Tuple_u32TxOutZ& operator=(C2Tuple_u32TxOutZ&& o) { C2Tuple_u32TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_u32TxOutZ)); return *this; }
11063 LDKC2Tuple_u32TxOutZ* operator &() { return &self; }
11064 LDKC2Tuple_u32TxOutZ* operator ->() { return &self; }
11065 const LDKC2Tuple_u32TxOutZ* operator &() const { return &self; }
11066 const LDKC2Tuple_u32TxOutZ* operator ->() const { return &self; }
11070 LDKCVec_UtxoZ self;
11072 CVec_UtxoZ(const CVec_UtxoZ&) = delete;
11073 CVec_UtxoZ(CVec_UtxoZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_UtxoZ)); }
11074 CVec_UtxoZ(LDKCVec_UtxoZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_UtxoZ)); }
11075 operator LDKCVec_UtxoZ() && { LDKCVec_UtxoZ res = self; memset(&self, 0, sizeof(LDKCVec_UtxoZ)); return res; }
11076 ~CVec_UtxoZ() { CVec_UtxoZ_free(self); }
11077 CVec_UtxoZ& operator=(CVec_UtxoZ&& o) { CVec_UtxoZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_UtxoZ)); return *this; }
11078 LDKCVec_UtxoZ* operator &() { return &self; }
11079 LDKCVec_UtxoZ* operator ->() { return &self; }
11080 const LDKCVec_UtxoZ* operator &() const { return &self; }
11081 const LDKCVec_UtxoZ* operator ->() const { return &self; }
11083 class CResult_ChannelConfigDecodeErrorZ {
11085 LDKCResult_ChannelConfigDecodeErrorZ self;
11087 CResult_ChannelConfigDecodeErrorZ(const CResult_ChannelConfigDecodeErrorZ&) = delete;
11088 CResult_ChannelConfigDecodeErrorZ(CResult_ChannelConfigDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); }
11089 CResult_ChannelConfigDecodeErrorZ(LDKCResult_ChannelConfigDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); }
11090 operator LDKCResult_ChannelConfigDecodeErrorZ() && { LDKCResult_ChannelConfigDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelConfigDecodeErrorZ)); return res; }
11091 ~CResult_ChannelConfigDecodeErrorZ() { CResult_ChannelConfigDecodeErrorZ_free(self); }
11092 CResult_ChannelConfigDecodeErrorZ& operator=(CResult_ChannelConfigDecodeErrorZ&& o) { CResult_ChannelConfigDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelConfigDecodeErrorZ)); return *this; }
11093 LDKCResult_ChannelConfigDecodeErrorZ* operator &() { return &self; }
11094 LDKCResult_ChannelConfigDecodeErrorZ* operator ->() { return &self; }
11095 const LDKCResult_ChannelConfigDecodeErrorZ* operator &() const { return &self; }
11096 const LDKCResult_ChannelConfigDecodeErrorZ* operator ->() const { return &self; }
11098 class CVec_PrivateRouteZ {
11100 LDKCVec_PrivateRouteZ self;
11102 CVec_PrivateRouteZ(const CVec_PrivateRouteZ&) = delete;
11103 CVec_PrivateRouteZ(CVec_PrivateRouteZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_PrivateRouteZ)); }
11104 CVec_PrivateRouteZ(LDKCVec_PrivateRouteZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_PrivateRouteZ)); }
11105 operator LDKCVec_PrivateRouteZ() && { LDKCVec_PrivateRouteZ res = self; memset(&self, 0, sizeof(LDKCVec_PrivateRouteZ)); return res; }
11106 ~CVec_PrivateRouteZ() { CVec_PrivateRouteZ_free(self); }
11107 CVec_PrivateRouteZ& operator=(CVec_PrivateRouteZ&& o) { CVec_PrivateRouteZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_PrivateRouteZ)); return *this; }
11108 LDKCVec_PrivateRouteZ* operator &() { return &self; }
11109 LDKCVec_PrivateRouteZ* operator ->() { return &self; }
11110 const LDKCVec_PrivateRouteZ* operator &() const { return &self; }
11111 const LDKCVec_PrivateRouteZ* operator ->() const { return &self; }
11113 class COption_i64Z {
11115 LDKCOption_i64Z self;
11117 COption_i64Z(const COption_i64Z&) = delete;
11118 COption_i64Z(COption_i64Z&& o) : self(o.self) { memset(&o, 0, sizeof(COption_i64Z)); }
11119 COption_i64Z(LDKCOption_i64Z&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_i64Z)); }
11120 operator LDKCOption_i64Z() && { LDKCOption_i64Z res = self; memset(&self, 0, sizeof(LDKCOption_i64Z)); return res; }
11121 ~COption_i64Z() { COption_i64Z_free(self); }
11122 COption_i64Z& operator=(COption_i64Z&& o) { COption_i64Z_free(self); self = o.self; memset(&o, 0, sizeof(COption_i64Z)); return *this; }
11123 LDKCOption_i64Z* operator &() { return &self; }
11124 LDKCOption_i64Z* operator ->() { return &self; }
11125 const LDKCOption_i64Z* operator &() const { return &self; }
11126 const LDKCOption_i64Z* operator ->() const { return &self; }
11128 class C2Tuple_ThirtyTwoBytesChannelManagerZ {
11130 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ self;
11132 C2Tuple_ThirtyTwoBytesChannelManagerZ(const C2Tuple_ThirtyTwoBytesChannelManagerZ&) = delete;
11133 C2Tuple_ThirtyTwoBytesChannelManagerZ(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); }
11134 C2Tuple_ThirtyTwoBytesChannelManagerZ(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); }
11135 operator LDKC2Tuple_ThirtyTwoBytesChannelManagerZ() && { LDKC2Tuple_ThirtyTwoBytesChannelManagerZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ)); return res; }
11136 ~C2Tuple_ThirtyTwoBytesChannelManagerZ() { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); }
11137 C2Tuple_ThirtyTwoBytesChannelManagerZ& operator=(C2Tuple_ThirtyTwoBytesChannelManagerZ&& o) { C2Tuple_ThirtyTwoBytesChannelManagerZ_free(self); self = o.self; memset(&o, 0, sizeof(C2Tuple_ThirtyTwoBytesChannelManagerZ)); return *this; }
11138 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() { return &self; }
11139 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() { return &self; }
11140 const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator &() const { return &self; }
11141 const LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* operator ->() const { return &self; }
11143 class CResult_COption_OnionMessageContentsZDecodeErrorZ {
11145 LDKCResult_COption_OnionMessageContentsZDecodeErrorZ self;
11147 CResult_COption_OnionMessageContentsZDecodeErrorZ(const CResult_COption_OnionMessageContentsZDecodeErrorZ&) = delete;
11148 CResult_COption_OnionMessageContentsZDecodeErrorZ(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); }
11149 CResult_COption_OnionMessageContentsZDecodeErrorZ(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); }
11150 operator LDKCResult_COption_OnionMessageContentsZDecodeErrorZ() && { LDKCResult_COption_OnionMessageContentsZDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_COption_OnionMessageContentsZDecodeErrorZ)); return res; }
11151 ~CResult_COption_OnionMessageContentsZDecodeErrorZ() { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); }
11152 CResult_COption_OnionMessageContentsZDecodeErrorZ& operator=(CResult_COption_OnionMessageContentsZDecodeErrorZ&& o) { CResult_COption_OnionMessageContentsZDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_COption_OnionMessageContentsZDecodeErrorZ)); return *this; }
11153 LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() { return &self; }
11154 LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() { return &self; }
11155 const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator &() const { return &self; }
11156 const LDKCResult_COption_OnionMessageContentsZDecodeErrorZ* operator ->() const { return &self; }
11158 class C2Tuple_u64CVec_u8ZZ {
11160 LDKC2Tuple_u64CVec_u8ZZ self;
11162 C2Tuple_u64CVec_u8ZZ(const C2Tuple_u64CVec_u8ZZ&) = delete;
11163 C2Tuple_u64CVec_u8ZZ(C2Tuple_u64CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(C2Tuple_u64CVec_u8ZZ)); }
11164 C2Tuple_u64CVec_u8ZZ(LDKC2Tuple_u64CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); }
11165 operator LDKC2Tuple_u64CVec_u8ZZ() && { LDKC2Tuple_u64CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKC2Tuple_u64CVec_u8ZZ)); return res; }
11166 ~C2Tuple_u64CVec_u8ZZ() { C2Tuple_u64CVec_u8ZZ_free(self); }
11167 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; }
11168 LDKC2Tuple_u64CVec_u8ZZ* operator &() { return &self; }
11169 LDKC2Tuple_u64CVec_u8ZZ* operator ->() { return &self; }
11170 const LDKC2Tuple_u64CVec_u8ZZ* operator &() const { return &self; }
11171 const LDKC2Tuple_u64CVec_u8ZZ* operator ->() const { return &self; }
11173 class CResult_OfferBolt12ParseErrorZ {
11175 LDKCResult_OfferBolt12ParseErrorZ self;
11177 CResult_OfferBolt12ParseErrorZ(const CResult_OfferBolt12ParseErrorZ&) = delete;
11178 CResult_OfferBolt12ParseErrorZ(CResult_OfferBolt12ParseErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); }
11179 CResult_OfferBolt12ParseErrorZ(LDKCResult_OfferBolt12ParseErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); }
11180 operator LDKCResult_OfferBolt12ParseErrorZ() && { LDKCResult_OfferBolt12ParseErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OfferBolt12ParseErrorZ)); return res; }
11181 ~CResult_OfferBolt12ParseErrorZ() { CResult_OfferBolt12ParseErrorZ_free(self); }
11182 CResult_OfferBolt12ParseErrorZ& operator=(CResult_OfferBolt12ParseErrorZ&& o) { CResult_OfferBolt12ParseErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OfferBolt12ParseErrorZ)); return *this; }
11183 LDKCResult_OfferBolt12ParseErrorZ* operator &() { return &self; }
11184 LDKCResult_OfferBolt12ParseErrorZ* operator ->() { return &self; }
11185 const LDKCResult_OfferBolt12ParseErrorZ* operator &() const { return &self; }
11186 const LDKCResult_OfferBolt12ParseErrorZ* operator ->() const { return &self; }
11188 class CResult_ThirtyTwoBytesRetryableSendFailureZ {
11190 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ self;
11192 CResult_ThirtyTwoBytesRetryableSendFailureZ(const CResult_ThirtyTwoBytesRetryableSendFailureZ&) = delete;
11193 CResult_ThirtyTwoBytesRetryableSendFailureZ(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); }
11194 CResult_ThirtyTwoBytesRetryableSendFailureZ(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); }
11195 operator LDKCResult_ThirtyTwoBytesRetryableSendFailureZ() && { LDKCResult_ThirtyTwoBytesRetryableSendFailureZ res = self; memset(&self, 0, sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ)); return res; }
11196 ~CResult_ThirtyTwoBytesRetryableSendFailureZ() { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); }
11197 CResult_ThirtyTwoBytesRetryableSendFailureZ& operator=(CResult_ThirtyTwoBytesRetryableSendFailureZ&& o) { CResult_ThirtyTwoBytesRetryableSendFailureZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ThirtyTwoBytesRetryableSendFailureZ)); return *this; }
11198 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() { return &self; }
11199 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() { return &self; }
11200 const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator &() const { return &self; }
11201 const LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* operator ->() const { return &self; }
11203 class CVec_MonitorEventZ {
11205 LDKCVec_MonitorEventZ self;
11207 CVec_MonitorEventZ(const CVec_MonitorEventZ&) = delete;
11208 CVec_MonitorEventZ(CVec_MonitorEventZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_MonitorEventZ)); }
11209 CVec_MonitorEventZ(LDKCVec_MonitorEventZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_MonitorEventZ)); }
11210 operator LDKCVec_MonitorEventZ() && { LDKCVec_MonitorEventZ res = self; memset(&self, 0, sizeof(LDKCVec_MonitorEventZ)); return res; }
11211 ~CVec_MonitorEventZ() { CVec_MonitorEventZ_free(self); }
11212 CVec_MonitorEventZ& operator=(CVec_MonitorEventZ&& o) { CVec_MonitorEventZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_MonitorEventZ)); return *this; }
11213 LDKCVec_MonitorEventZ* operator &() { return &self; }
11214 LDKCVec_MonitorEventZ* operator ->() { return &self; }
11215 const LDKCVec_MonitorEventZ* operator &() const { return &self; }
11216 const LDKCVec_MonitorEventZ* operator ->() const { return &self; }
11218 class CResult_ShutdownDecodeErrorZ {
11220 LDKCResult_ShutdownDecodeErrorZ self;
11222 CResult_ShutdownDecodeErrorZ(const CResult_ShutdownDecodeErrorZ&) = delete;
11223 CResult_ShutdownDecodeErrorZ(CResult_ShutdownDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); }
11224 CResult_ShutdownDecodeErrorZ(LDKCResult_ShutdownDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); }
11225 operator LDKCResult_ShutdownDecodeErrorZ() && { LDKCResult_ShutdownDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ShutdownDecodeErrorZ)); return res; }
11226 ~CResult_ShutdownDecodeErrorZ() { CResult_ShutdownDecodeErrorZ_free(self); }
11227 CResult_ShutdownDecodeErrorZ& operator=(CResult_ShutdownDecodeErrorZ&& o) { CResult_ShutdownDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ShutdownDecodeErrorZ)); return *this; }
11228 LDKCResult_ShutdownDecodeErrorZ* operator &() { return &self; }
11229 LDKCResult_ShutdownDecodeErrorZ* operator ->() { return &self; }
11230 const LDKCResult_ShutdownDecodeErrorZ* operator &() const { return &self; }
11231 const LDKCResult_ShutdownDecodeErrorZ* operator ->() const { return &self; }
11233 class CResult_BigSizeDecodeErrorZ {
11235 LDKCResult_BigSizeDecodeErrorZ self;
11237 CResult_BigSizeDecodeErrorZ(const CResult_BigSizeDecodeErrorZ&) = delete;
11238 CResult_BigSizeDecodeErrorZ(CResult_BigSizeDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); }
11239 CResult_BigSizeDecodeErrorZ(LDKCResult_BigSizeDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); }
11240 operator LDKCResult_BigSizeDecodeErrorZ() && { LDKCResult_BigSizeDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BigSizeDecodeErrorZ)); return res; }
11241 ~CResult_BigSizeDecodeErrorZ() { CResult_BigSizeDecodeErrorZ_free(self); }
11242 CResult_BigSizeDecodeErrorZ& operator=(CResult_BigSizeDecodeErrorZ&& o) { CResult_BigSizeDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BigSizeDecodeErrorZ)); return *this; }
11243 LDKCResult_BigSizeDecodeErrorZ* operator &() { return &self; }
11244 LDKCResult_BigSizeDecodeErrorZ* operator ->() { return &self; }
11245 const LDKCResult_BigSizeDecodeErrorZ* operator &() const { return &self; }
11246 const LDKCResult_BigSizeDecodeErrorZ* operator ->() const { return &self; }
11248 class CResult_TxOutUtxoLookupErrorZ {
11250 LDKCResult_TxOutUtxoLookupErrorZ self;
11252 CResult_TxOutUtxoLookupErrorZ(const CResult_TxOutUtxoLookupErrorZ&) = delete;
11253 CResult_TxOutUtxoLookupErrorZ(CResult_TxOutUtxoLookupErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); }
11254 CResult_TxOutUtxoLookupErrorZ(LDKCResult_TxOutUtxoLookupErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); }
11255 operator LDKCResult_TxOutUtxoLookupErrorZ() && { LDKCResult_TxOutUtxoLookupErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxOutUtxoLookupErrorZ)); return res; }
11256 ~CResult_TxOutUtxoLookupErrorZ() { CResult_TxOutUtxoLookupErrorZ_free(self); }
11257 CResult_TxOutUtxoLookupErrorZ& operator=(CResult_TxOutUtxoLookupErrorZ&& o) { CResult_TxOutUtxoLookupErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxOutUtxoLookupErrorZ)); return *this; }
11258 LDKCResult_TxOutUtxoLookupErrorZ* operator &() { return &self; }
11259 LDKCResult_TxOutUtxoLookupErrorZ* operator ->() { return &self; }
11260 const LDKCResult_TxOutUtxoLookupErrorZ* operator &() const { return &self; }
11261 const LDKCResult_TxOutUtxoLookupErrorZ* operator ->() const { return &self; }
11263 class CResult_BlindedPathNoneZ {
11265 LDKCResult_BlindedPathNoneZ self;
11267 CResult_BlindedPathNoneZ(const CResult_BlindedPathNoneZ&) = delete;
11268 CResult_BlindedPathNoneZ(CResult_BlindedPathNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); }
11269 CResult_BlindedPathNoneZ(LDKCResult_BlindedPathNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); }
11270 operator LDKCResult_BlindedPathNoneZ() && { LDKCResult_BlindedPathNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedPathNoneZ)); return res; }
11271 ~CResult_BlindedPathNoneZ() { CResult_BlindedPathNoneZ_free(self); }
11272 CResult_BlindedPathNoneZ& operator=(CResult_BlindedPathNoneZ&& o) { CResult_BlindedPathNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedPathNoneZ)); return *this; }
11273 LDKCResult_BlindedPathNoneZ* operator &() { return &self; }
11274 LDKCResult_BlindedPathNoneZ* operator ->() { return &self; }
11275 const LDKCResult_BlindedPathNoneZ* operator &() const { return &self; }
11276 const LDKCResult_BlindedPathNoneZ* operator ->() const { return &self; }
11278 class COption_usizeZ {
11280 LDKCOption_usizeZ self;
11282 COption_usizeZ(const COption_usizeZ&) = delete;
11283 COption_usizeZ(COption_usizeZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_usizeZ)); }
11284 COption_usizeZ(LDKCOption_usizeZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_usizeZ)); }
11285 operator LDKCOption_usizeZ() && { LDKCOption_usizeZ res = self; memset(&self, 0, sizeof(LDKCOption_usizeZ)); return res; }
11286 ~COption_usizeZ() { COption_usizeZ_free(self); }
11287 COption_usizeZ& operator=(COption_usizeZ&& o) { COption_usizeZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_usizeZ)); return *this; }
11288 LDKCOption_usizeZ* operator &() { return &self; }
11289 LDKCOption_usizeZ* operator ->() { return &self; }
11290 const LDKCOption_usizeZ* operator &() const { return &self; }
11291 const LDKCOption_usizeZ* operator ->() const { return &self; }
11293 class CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
11295 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ self;
11297 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(const CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&) = delete;
11298 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
11299 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); }
11300 operator LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() && { LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ res = self; memset(&self, 0, sizeof(LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ)); return res; }
11301 ~CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ() { CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(self); }
11302 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; }
11303 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() { return &self; }
11304 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() { return &self; }
11305 const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator &() const { return &self; }
11306 const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ* operator ->() const { return &self; }
11308 class CResult_NoneNoneZ {
11310 LDKCResult_NoneNoneZ self;
11312 CResult_NoneNoneZ(const CResult_NoneNoneZ&) = delete;
11313 CResult_NoneNoneZ(CResult_NoneNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_NoneNoneZ)); }
11314 CResult_NoneNoneZ(LDKCResult_NoneNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_NoneNoneZ)); }
11315 operator LDKCResult_NoneNoneZ() && { LDKCResult_NoneNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_NoneNoneZ)); return res; }
11316 ~CResult_NoneNoneZ() { CResult_NoneNoneZ_free(self); }
11317 CResult_NoneNoneZ& operator=(CResult_NoneNoneZ&& o) { CResult_NoneNoneZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_NoneNoneZ)); return *this; }
11318 LDKCResult_NoneNoneZ* operator &() { return &self; }
11319 LDKCResult_NoneNoneZ* operator ->() { return &self; }
11320 const LDKCResult_NoneNoneZ* operator &() const { return &self; }
11321 const LDKCResult_NoneNoneZ* operator ->() const { return &self; }
11323 class CResult_boolPeerHandleErrorZ {
11325 LDKCResult_boolPeerHandleErrorZ self;
11327 CResult_boolPeerHandleErrorZ(const CResult_boolPeerHandleErrorZ&) = delete;
11328 CResult_boolPeerHandleErrorZ(CResult_boolPeerHandleErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); }
11329 CResult_boolPeerHandleErrorZ(LDKCResult_boolPeerHandleErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); }
11330 operator LDKCResult_boolPeerHandleErrorZ() && { LDKCResult_boolPeerHandleErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_boolPeerHandleErrorZ)); return res; }
11331 ~CResult_boolPeerHandleErrorZ() { CResult_boolPeerHandleErrorZ_free(self); }
11332 CResult_boolPeerHandleErrorZ& operator=(CResult_boolPeerHandleErrorZ&& o) { CResult_boolPeerHandleErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_boolPeerHandleErrorZ)); return *this; }
11333 LDKCResult_boolPeerHandleErrorZ* operator &() { return &self; }
11334 LDKCResult_boolPeerHandleErrorZ* operator ->() { return &self; }
11335 const LDKCResult_boolPeerHandleErrorZ* operator &() const { return &self; }
11336 const LDKCResult_boolPeerHandleErrorZ* operator ->() const { return &self; }
11338 class CResult_ChannelUpdateDecodeErrorZ {
11340 LDKCResult_ChannelUpdateDecodeErrorZ self;
11342 CResult_ChannelUpdateDecodeErrorZ(const CResult_ChannelUpdateDecodeErrorZ&) = delete;
11343 CResult_ChannelUpdateDecodeErrorZ(CResult_ChannelUpdateDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); }
11344 CResult_ChannelUpdateDecodeErrorZ(LDKCResult_ChannelUpdateDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); }
11345 operator LDKCResult_ChannelUpdateDecodeErrorZ() && { LDKCResult_ChannelUpdateDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_ChannelUpdateDecodeErrorZ)); return res; }
11346 ~CResult_ChannelUpdateDecodeErrorZ() { CResult_ChannelUpdateDecodeErrorZ_free(self); }
11347 CResult_ChannelUpdateDecodeErrorZ& operator=(CResult_ChannelUpdateDecodeErrorZ&& o) { CResult_ChannelUpdateDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_ChannelUpdateDecodeErrorZ)); return *this; }
11348 LDKCResult_ChannelUpdateDecodeErrorZ* operator &() { return &self; }
11349 LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() { return &self; }
11350 const LDKCResult_ChannelUpdateDecodeErrorZ* operator &() const { return &self; }
11351 const LDKCResult_ChannelUpdateDecodeErrorZ* operator ->() const { return &self; }
11353 class CVec_APIErrorZ {
11355 LDKCVec_APIErrorZ self;
11357 CVec_APIErrorZ(const CVec_APIErrorZ&) = delete;
11358 CVec_APIErrorZ(CVec_APIErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CVec_APIErrorZ)); }
11359 CVec_APIErrorZ(LDKCVec_APIErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCVec_APIErrorZ)); }
11360 operator LDKCVec_APIErrorZ() && { LDKCVec_APIErrorZ res = self; memset(&self, 0, sizeof(LDKCVec_APIErrorZ)); return res; }
11361 ~CVec_APIErrorZ() { CVec_APIErrorZ_free(self); }
11362 CVec_APIErrorZ& operator=(CVec_APIErrorZ&& o) { CVec_APIErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CVec_APIErrorZ)); return *this; }
11363 LDKCVec_APIErrorZ* operator &() { return &self; }
11364 LDKCVec_APIErrorZ* operator ->() { return &self; }
11365 const LDKCVec_APIErrorZ* operator &() const { return &self; }
11366 const LDKCVec_APIErrorZ* operator ->() const { return &self; }
11368 class COption_TxOutZ {
11370 LDKCOption_TxOutZ self;
11372 COption_TxOutZ(const COption_TxOutZ&) = delete;
11373 COption_TxOutZ(COption_TxOutZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_TxOutZ)); }
11374 COption_TxOutZ(LDKCOption_TxOutZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_TxOutZ)); }
11375 operator LDKCOption_TxOutZ() && { LDKCOption_TxOutZ res = self; memset(&self, 0, sizeof(LDKCOption_TxOutZ)); return res; }
11376 ~COption_TxOutZ() { COption_TxOutZ_free(self); }
11377 COption_TxOutZ& operator=(COption_TxOutZ&& o) { COption_TxOutZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_TxOutZ)); return *this; }
11378 LDKCOption_TxOutZ* operator &() { return &self; }
11379 LDKCOption_TxOutZ* operator ->() { return &self; }
11380 const LDKCOption_TxOutZ* operator &() const { return &self; }
11381 const LDKCOption_TxOutZ* operator ->() const { return &self; }
11383 class COption_ClosureReasonZ {
11385 LDKCOption_ClosureReasonZ self;
11387 COption_ClosureReasonZ(const COption_ClosureReasonZ&) = delete;
11388 COption_ClosureReasonZ(COption_ClosureReasonZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_ClosureReasonZ)); }
11389 COption_ClosureReasonZ(LDKCOption_ClosureReasonZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_ClosureReasonZ)); }
11390 operator LDKCOption_ClosureReasonZ() && { LDKCOption_ClosureReasonZ res = self; memset(&self, 0, sizeof(LDKCOption_ClosureReasonZ)); return res; }
11391 ~COption_ClosureReasonZ() { COption_ClosureReasonZ_free(self); }
11392 COption_ClosureReasonZ& operator=(COption_ClosureReasonZ&& o) { COption_ClosureReasonZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_ClosureReasonZ)); return *this; }
11393 LDKCOption_ClosureReasonZ* operator &() { return &self; }
11394 LDKCOption_ClosureReasonZ* operator ->() { return &self; }
11395 const LDKCOption_ClosureReasonZ* operator &() const { return &self; }
11396 const LDKCOption_ClosureReasonZ* operator ->() const { return &self; }
11398 class CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ {
11400 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ self;
11402 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(const CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&) = delete;
11403 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
11404 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); }
11405 operator LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ)); return res; }
11406 ~CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ() { CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(self); }
11407 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; }
11408 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() { return &self; }
11409 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() { return &self; }
11410 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator &() const { return &self; }
11411 const LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* operator ->() const { return &self; }
11413 class CResult_TransactionU16LenLimitedDecodeErrorZ {
11415 LDKCResult_TransactionU16LenLimitedDecodeErrorZ self;
11417 CResult_TransactionU16LenLimitedDecodeErrorZ(const CResult_TransactionU16LenLimitedDecodeErrorZ&) = delete;
11418 CResult_TransactionU16LenLimitedDecodeErrorZ(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); }
11419 CResult_TransactionU16LenLimitedDecodeErrorZ(LDKCResult_TransactionU16LenLimitedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); }
11420 operator LDKCResult_TransactionU16LenLimitedDecodeErrorZ() && { LDKCResult_TransactionU16LenLimitedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ)); return res; }
11421 ~CResult_TransactionU16LenLimitedDecodeErrorZ() { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); }
11422 CResult_TransactionU16LenLimitedDecodeErrorZ& operator=(CResult_TransactionU16LenLimitedDecodeErrorZ&& o) { CResult_TransactionU16LenLimitedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TransactionU16LenLimitedDecodeErrorZ)); return *this; }
11423 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() { return &self; }
11424 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() { return &self; }
11425 const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator &() const { return &self; }
11426 const LDKCResult_TransactionU16LenLimitedDecodeErrorZ* operator ->() const { return &self; }
11428 class CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ {
11430 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ self;
11432 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(const CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&) = delete;
11433 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
11434 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); }
11435 operator LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() && { LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ)); return res; }
11436 ~CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ() { CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(self); }
11437 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; }
11438 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() { return &self; }
11439 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() { return &self; }
11440 const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator &() const { return &self; }
11441 const LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* operator ->() const { return &self; }
11443 class CResult_CounterpartyForwardingInfoDecodeErrorZ {
11445 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ self;
11447 CResult_CounterpartyForwardingInfoDecodeErrorZ(const CResult_CounterpartyForwardingInfoDecodeErrorZ&) = delete;
11448 CResult_CounterpartyForwardingInfoDecodeErrorZ(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); }
11449 CResult_CounterpartyForwardingInfoDecodeErrorZ(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); }
11450 operator LDKCResult_CounterpartyForwardingInfoDecodeErrorZ() && { LDKCResult_CounterpartyForwardingInfoDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ)); return res; }
11451 ~CResult_CounterpartyForwardingInfoDecodeErrorZ() { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); }
11452 CResult_CounterpartyForwardingInfoDecodeErrorZ& operator=(CResult_CounterpartyForwardingInfoDecodeErrorZ&& o) { CResult_CounterpartyForwardingInfoDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_CounterpartyForwardingInfoDecodeErrorZ)); return *this; }
11453 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() { return &self; }
11454 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() { return &self; }
11455 const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator &() const { return &self; }
11456 const LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* operator ->() const { return &self; }
11458 class CResult_OpenChannelV2DecodeErrorZ {
11460 LDKCResult_OpenChannelV2DecodeErrorZ self;
11462 CResult_OpenChannelV2DecodeErrorZ(const CResult_OpenChannelV2DecodeErrorZ&) = delete;
11463 CResult_OpenChannelV2DecodeErrorZ(CResult_OpenChannelV2DecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); }
11464 CResult_OpenChannelV2DecodeErrorZ(LDKCResult_OpenChannelV2DecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); }
11465 operator LDKCResult_OpenChannelV2DecodeErrorZ() && { LDKCResult_OpenChannelV2DecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_OpenChannelV2DecodeErrorZ)); return res; }
11466 ~CResult_OpenChannelV2DecodeErrorZ() { CResult_OpenChannelV2DecodeErrorZ_free(self); }
11467 CResult_OpenChannelV2DecodeErrorZ& operator=(CResult_OpenChannelV2DecodeErrorZ&& o) { CResult_OpenChannelV2DecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_OpenChannelV2DecodeErrorZ)); return *this; }
11468 LDKCResult_OpenChannelV2DecodeErrorZ* operator &() { return &self; }
11469 LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() { return &self; }
11470 const LDKCResult_OpenChannelV2DecodeErrorZ* operator &() const { return &self; }
11471 const LDKCResult_OpenChannelV2DecodeErrorZ* operator ->() const { return &self; }
11473 class CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ {
11475 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ self;
11477 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(const CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&) = delete;
11478 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
11479 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); }
11480 operator LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() && { LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ res = self; memset(&self, 0, sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ)); return res; }
11481 ~CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ() { CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(self); }
11482 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; }
11483 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() { return &self; }
11484 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() { return &self; }
11485 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator &() const { return &self; }
11486 const LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* operator ->() const { return &self; }
11488 class CResult_HtlcBasepointDecodeErrorZ {
11490 LDKCResult_HtlcBasepointDecodeErrorZ self;
11492 CResult_HtlcBasepointDecodeErrorZ(const CResult_HtlcBasepointDecodeErrorZ&) = delete;
11493 CResult_HtlcBasepointDecodeErrorZ(CResult_HtlcBasepointDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); }
11494 CResult_HtlcBasepointDecodeErrorZ(LDKCResult_HtlcBasepointDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); }
11495 operator LDKCResult_HtlcBasepointDecodeErrorZ() && { LDKCResult_HtlcBasepointDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_HtlcBasepointDecodeErrorZ)); return res; }
11496 ~CResult_HtlcBasepointDecodeErrorZ() { CResult_HtlcBasepointDecodeErrorZ_free(self); }
11497 CResult_HtlcBasepointDecodeErrorZ& operator=(CResult_HtlcBasepointDecodeErrorZ&& o) { CResult_HtlcBasepointDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_HtlcBasepointDecodeErrorZ)); return *this; }
11498 LDKCResult_HtlcBasepointDecodeErrorZ* operator &() { return &self; }
11499 LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() { return &self; }
11500 const LDKCResult_HtlcBasepointDecodeErrorZ* operator &() const { return &self; }
11501 const LDKCResult_HtlcBasepointDecodeErrorZ* operator ->() const { return &self; }
11503 class CResult_SpliceLockedDecodeErrorZ {
11505 LDKCResult_SpliceLockedDecodeErrorZ self;
11507 CResult_SpliceLockedDecodeErrorZ(const CResult_SpliceLockedDecodeErrorZ&) = delete;
11508 CResult_SpliceLockedDecodeErrorZ(CResult_SpliceLockedDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); }
11509 CResult_SpliceLockedDecodeErrorZ(LDKCResult_SpliceLockedDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); }
11510 operator LDKCResult_SpliceLockedDecodeErrorZ() && { LDKCResult_SpliceLockedDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_SpliceLockedDecodeErrorZ)); return res; }
11511 ~CResult_SpliceLockedDecodeErrorZ() { CResult_SpliceLockedDecodeErrorZ_free(self); }
11512 CResult_SpliceLockedDecodeErrorZ& operator=(CResult_SpliceLockedDecodeErrorZ&& o) { CResult_SpliceLockedDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_SpliceLockedDecodeErrorZ)); return *this; }
11513 LDKCResult_SpliceLockedDecodeErrorZ* operator &() { return &self; }
11514 LDKCResult_SpliceLockedDecodeErrorZ* operator ->() { return &self; }
11515 const LDKCResult_SpliceLockedDecodeErrorZ* operator &() const { return &self; }
11516 const LDKCResult_SpliceLockedDecodeErrorZ* operator ->() const { return &self; }
11518 class CResult_RouteDecodeErrorZ {
11520 LDKCResult_RouteDecodeErrorZ self;
11522 CResult_RouteDecodeErrorZ(const CResult_RouteDecodeErrorZ&) = delete;
11523 CResult_RouteDecodeErrorZ(CResult_RouteDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); }
11524 CResult_RouteDecodeErrorZ(LDKCResult_RouteDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); }
11525 operator LDKCResult_RouteDecodeErrorZ() && { LDKCResult_RouteDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_RouteDecodeErrorZ)); return res; }
11526 ~CResult_RouteDecodeErrorZ() { CResult_RouteDecodeErrorZ_free(self); }
11527 CResult_RouteDecodeErrorZ& operator=(CResult_RouteDecodeErrorZ&& o) { CResult_RouteDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_RouteDecodeErrorZ)); return *this; }
11528 LDKCResult_RouteDecodeErrorZ* operator &() { return &self; }
11529 LDKCResult_RouteDecodeErrorZ* operator ->() { return &self; }
11530 const LDKCResult_RouteDecodeErrorZ* operator &() const { return &self; }
11531 const LDKCResult_RouteDecodeErrorZ* operator ->() const { return &self; }
11533 class CResult_BlindedFailureDecodeErrorZ {
11535 LDKCResult_BlindedFailureDecodeErrorZ self;
11537 CResult_BlindedFailureDecodeErrorZ(const CResult_BlindedFailureDecodeErrorZ&) = delete;
11538 CResult_BlindedFailureDecodeErrorZ(CResult_BlindedFailureDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); }
11539 CResult_BlindedFailureDecodeErrorZ(LDKCResult_BlindedFailureDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); }
11540 operator LDKCResult_BlindedFailureDecodeErrorZ() && { LDKCResult_BlindedFailureDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_BlindedFailureDecodeErrorZ)); return res; }
11541 ~CResult_BlindedFailureDecodeErrorZ() { CResult_BlindedFailureDecodeErrorZ_free(self); }
11542 CResult_BlindedFailureDecodeErrorZ& operator=(CResult_BlindedFailureDecodeErrorZ&& o) { CResult_BlindedFailureDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_BlindedFailureDecodeErrorZ)); return *this; }
11543 LDKCResult_BlindedFailureDecodeErrorZ* operator &() { return &self; }
11544 LDKCResult_BlindedFailureDecodeErrorZ* operator ->() { return &self; }
11545 const LDKCResult_BlindedFailureDecodeErrorZ* operator &() const { return &self; }
11546 const LDKCResult_BlindedFailureDecodeErrorZ* operator ->() const { return &self; }
11548 class CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ {
11550 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ self;
11552 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(const CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&) = delete;
11553 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
11554 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); }
11555 operator LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() && { LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ)); return res; }
11556 ~CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ() { CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(self); }
11557 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; }
11558 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() { return &self; }
11559 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() { return &self; }
11560 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator &() const { return &self; }
11561 const LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* operator ->() const { return &self; }
11563 class COption_NoneZ {
11565 LDKCOption_NoneZ self;
11567 COption_NoneZ(const COption_NoneZ&) = delete;
11568 COption_NoneZ(COption_NoneZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_NoneZ)); }
11569 COption_NoneZ(LDKCOption_NoneZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_NoneZ)); }
11570 operator LDKCOption_NoneZ() && { LDKCOption_NoneZ res = self; memset(&self, 0, sizeof(LDKCOption_NoneZ)); return res; }
11571 ~COption_NoneZ() { COption_NoneZ_free(self); }
11572 COption_NoneZ& operator=(COption_NoneZ&& o) { COption_NoneZ_free(self); self = o.self; memset(&o, 0, sizeof(COption_NoneZ)); return *this; }
11573 LDKCOption_NoneZ* operator &() { return &self; }
11574 LDKCOption_NoneZ* operator ->() { return &self; }
11575 const LDKCOption_NoneZ* operator &() const { return &self; }
11576 const LDKCOption_NoneZ* operator ->() const { return &self; }
11578 class CResult_TxAddOutputDecodeErrorZ {
11580 LDKCResult_TxAddOutputDecodeErrorZ self;
11582 CResult_TxAddOutputDecodeErrorZ(const CResult_TxAddOutputDecodeErrorZ&) = delete;
11583 CResult_TxAddOutputDecodeErrorZ(CResult_TxAddOutputDecodeErrorZ&& o) : self(o.self) { memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); }
11584 CResult_TxAddOutputDecodeErrorZ(LDKCResult_TxAddOutputDecodeErrorZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); }
11585 operator LDKCResult_TxAddOutputDecodeErrorZ() && { LDKCResult_TxAddOutputDecodeErrorZ res = self; memset(&self, 0, sizeof(LDKCResult_TxAddOutputDecodeErrorZ)); return res; }
11586 ~CResult_TxAddOutputDecodeErrorZ() { CResult_TxAddOutputDecodeErrorZ_free(self); }
11587 CResult_TxAddOutputDecodeErrorZ& operator=(CResult_TxAddOutputDecodeErrorZ&& o) { CResult_TxAddOutputDecodeErrorZ_free(self); self = o.self; memset(&o, 0, sizeof(CResult_TxAddOutputDecodeErrorZ)); return *this; }
11588 LDKCResult_TxAddOutputDecodeErrorZ* operator &() { return &self; }
11589 LDKCResult_TxAddOutputDecodeErrorZ* operator ->() { return &self; }
11590 const LDKCResult_TxAddOutputDecodeErrorZ* operator &() const { return &self; }
11591 const LDKCResult_TxAddOutputDecodeErrorZ* operator ->() const { return &self; }
11593 class COption_CVec_u8ZZ {
11595 LDKCOption_CVec_u8ZZ self;
11597 COption_CVec_u8ZZ(const COption_CVec_u8ZZ&) = delete;
11598 COption_CVec_u8ZZ(COption_CVec_u8ZZ&& o) : self(o.self) { memset(&o, 0, sizeof(COption_CVec_u8ZZ)); }
11599 COption_CVec_u8ZZ(LDKCOption_CVec_u8ZZ&& m_self) : self(m_self) { memset(&m_self, 0, sizeof(LDKCOption_CVec_u8ZZ)); }
11600 operator LDKCOption_CVec_u8ZZ() && { LDKCOption_CVec_u8ZZ res = self; memset(&self, 0, sizeof(LDKCOption_CVec_u8ZZ)); return res; }
11601 ~COption_CVec_u8ZZ() { COption_CVec_u8ZZ_free(self); }
11602 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; }
11603 LDKCOption_CVec_u8ZZ* operator &() { return &self; }
11604 LDKCOption_CVec_u8ZZ* operator ->() { return &self; }
11605 const LDKCOption_CVec_u8ZZ* operator &() const { return &self; }
11606 const LDKCOption_CVec_u8ZZ* operator ->() const { return &self; }
11609 inline LDKPublicKey ChannelSigner::get_per_commitment_point(uint64_t idx) {
11610 LDKPublicKey ret = (self.get_per_commitment_point)(self.this_arg, idx);
11613 inline LDKThirtyTwoBytes ChannelSigner::release_commitment_secret(uint64_t idx) {
11614 LDKThirtyTwoBytes ret = (self.release_commitment_secret)(self.this_arg, idx);
11617 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
11618 LDK::CResult_NoneNoneZ ret = (self.validate_holder_commitment)(self.this_arg, holder_tx, outbound_htlc_preimages);
11621 inline LDK::CResult_NoneNoneZ ChannelSigner::validate_counterparty_revocation(uint64_t idx, const uint8_t (*secret)[32]) {
11622 LDK::CResult_NoneNoneZ ret = (self.validate_counterparty_revocation)(self.this_arg, idx, secret);
11625 inline LDKThirtyTwoBytes ChannelSigner::channel_keys_id() {
11626 LDKThirtyTwoBytes ret = (self.channel_keys_id)(self.this_arg);
11629 inline void ChannelSigner::provide_channel_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters) {
11630 (self.provide_channel_parameters)(self.this_arg, channel_parameters);
11632 inline LDKThirtyTwoBytes EntropySource::get_secure_random_bytes() {
11633 LDKThirtyTwoBytes ret = (self.get_secure_random_bytes)(self.this_arg);
11636 inline LDKThirtyTwoBytes NodeSigner::get_inbound_payment_key_material() {
11637 LDKThirtyTwoBytes ret = (self.get_inbound_payment_key_material)(self.this_arg);
11640 inline LDK::CResult_PublicKeyNoneZ NodeSigner::get_node_id(enum LDKRecipient recipient) {
11641 LDK::CResult_PublicKeyNoneZ ret = (self.get_node_id)(self.this_arg, recipient);
11644 inline LDK::CResult_ThirtyTwoBytesNoneZ NodeSigner::ecdh(enum LDKRecipient recipient, struct LDKPublicKey other_key, struct LDKCOption_BigEndianScalarZ tweak) {
11645 LDK::CResult_ThirtyTwoBytesNoneZ ret = (self.ecdh)(self.this_arg, recipient, other_key, tweak);
11648 inline LDK::CResult_RecoverableSignatureNoneZ NodeSigner::sign_invoice(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z invoice_data, enum LDKRecipient recipient) {
11649 LDK::CResult_RecoverableSignatureNoneZ ret = (self.sign_invoice)(self.this_arg, hrp_bytes, invoice_data, recipient);
11652 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice_request(const struct LDKUnsignedInvoiceRequest *NONNULL_PTR invoice_request) {
11653 LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice_request)(self.this_arg, invoice_request);
11656 inline LDK::CResult_SchnorrSignatureNoneZ NodeSigner::sign_bolt12_invoice(const struct LDKUnsignedBolt12Invoice *NONNULL_PTR invoice) {
11657 LDK::CResult_SchnorrSignatureNoneZ ret = (self.sign_bolt12_invoice)(self.this_arg, invoice);
11660 inline LDK::CResult_ECDSASignatureNoneZ NodeSigner::sign_gossip_message(struct LDKUnsignedGossipMessage msg) {
11661 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_gossip_message)(self.this_arg, msg);
11664 inline LDKThirtyTwoBytes SignerProvider::generate_channel_keys_id(bool inbound, uint64_t channel_value_satoshis, struct LDKU128 user_channel_id) {
11665 LDKThirtyTwoBytes ret = (self.generate_channel_keys_id)(self.this_arg, inbound, channel_value_satoshis, user_channel_id);
11668 inline LDK::WriteableEcdsaChannelSigner SignerProvider::derive_channel_signer(uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id) {
11669 LDK::WriteableEcdsaChannelSigner ret = (self.derive_channel_signer)(self.this_arg, channel_value_satoshis, channel_keys_id);
11672 inline LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ SignerProvider::read_chan_signer(struct LDKu8slice reader) {
11673 LDK::CResult_WriteableEcdsaChannelSignerDecodeErrorZ ret = (self.read_chan_signer)(self.this_arg, reader);
11676 inline LDK::CResult_CVec_u8ZNoneZ SignerProvider::get_destination_script(struct LDKThirtyTwoBytes channel_keys_id) {
11677 LDK::CResult_CVec_u8ZNoneZ ret = (self.get_destination_script)(self.this_arg, channel_keys_id);
11680 inline LDK::CResult_ShutdownScriptNoneZ SignerProvider::get_shutdown_scriptpubkey() {
11681 LDK::CResult_ShutdownScriptNoneZ ret = (self.get_shutdown_scriptpubkey)(self.this_arg);
11684 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) {
11685 LDK::CResult_RouteLightningErrorZ ret = (self.find_route)(self.this_arg, payer, route_params, first_hops, inflight_htlcs);
11688 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) {
11689 LDK::CResult_RouteLightningErrorZ ret = (self.find_route_with_id)(self.this_arg, payer, route_params, first_hops, inflight_htlcs, _payment_hash, _payment_id);
11692 inline LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ Router::create_blinded_payment_paths(struct LDKPublicKey recipient, struct LDKCVec_ChannelDetailsZ first_hops, struct LDKReceiveTlvs tlvs, uint64_t amount_msats) {
11693 LDK::CResult_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ ret = (self.create_blinded_payment_paths)(self.this_arg, recipient, first_hops, tlvs, amount_msats);
11696 inline uint64_t ScoreLookUp::channel_penalty_msat(const struct LDKCandidateRouteHop *NONNULL_PTR candidate, struct LDKChannelUsage usage, const struct LDKProbabilisticScoringFeeParameters *NONNULL_PTR score_params) {
11697 uint64_t ret = (self.channel_penalty_msat)(self.this_arg, candidate, usage, score_params);
11700 inline void ScoreUpdate::payment_path_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
11701 (self.payment_path_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
11703 inline void ScoreUpdate::payment_path_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
11704 (self.payment_path_successful)(self.this_arg, path, duration_since_epoch);
11706 inline void ScoreUpdate::probe_failed(const struct LDKPath *NONNULL_PTR path, uint64_t short_channel_id, uint64_t duration_since_epoch) {
11707 (self.probe_failed)(self.this_arg, path, short_channel_id, duration_since_epoch);
11709 inline void ScoreUpdate::probe_successful(const struct LDKPath *NONNULL_PTR path, uint64_t duration_since_epoch) {
11710 (self.probe_successful)(self.this_arg, path, duration_since_epoch);
11712 inline void ScoreUpdate::time_passed(uint64_t duration_since_epoch) {
11713 (self.time_passed)(self.this_arg, duration_since_epoch);
11715 inline LDK::ScoreLookUp LockableScore::read_lock() {
11716 LDK::ScoreLookUp ret = (self.read_lock)(self.this_arg);
11719 inline LDK::ScoreUpdate LockableScore::write_lock() {
11720 LDK::ScoreUpdate ret = (self.write_lock)(self.this_arg);
11723 inline void Listen::filtered_block_connected(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11724 (self.filtered_block_connected)(self.this_arg, header, txdata, height);
11726 inline void Listen::block_connected(struct LDKu8slice block, uint32_t height) {
11727 (self.block_connected)(self.this_arg, block, height);
11729 inline void Listen::block_disconnected(const uint8_t (*header)[80], uint32_t height) {
11730 (self.block_disconnected)(self.this_arg, header, height);
11732 inline void Confirm::transactions_confirmed(const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11733 (self.transactions_confirmed)(self.this_arg, header, txdata, height);
11735 inline void Confirm::transaction_unconfirmed(const uint8_t (*txid)[32]) {
11736 (self.transaction_unconfirmed)(self.this_arg, txid);
11738 inline void Confirm::best_block_updated(const uint8_t (*header)[80], uint32_t height) {
11739 (self.best_block_updated)(self.this_arg, header, height);
11741 inline LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ Confirm::get_relevant_txids() {
11742 LDK::CVec_C3Tuple_ThirtyTwoBytesu32COption_ThirtyTwoBytesZZZ ret = (self.get_relevant_txids)(self.this_arg);
11745 inline LDK::CResult_ChannelMonitorUpdateStatusNoneZ Watch::watch_channel(struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor) {
11746 LDK::CResult_ChannelMonitorUpdateStatusNoneZ ret = (self.watch_channel)(self.this_arg, funding_txo, monitor);
11749 inline LDK::ChannelMonitorUpdateStatus Watch::update_channel(struct LDKOutPoint funding_txo, const struct LDKChannelMonitorUpdate *NONNULL_PTR update) {
11750 LDK::ChannelMonitorUpdateStatus ret = (self.update_channel)(self.this_arg, funding_txo, update);
11753 inline LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch::release_pending_monitor_events() {
11754 LDK::CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = (self.release_pending_monitor_events)(self.this_arg);
11757 inline void Filter::register_tx(const uint8_t (*txid)[32], struct LDKu8slice script_pubkey) {
11758 (self.register_tx)(self.this_arg, txid, script_pubkey);
11760 inline void Filter::register_output(struct LDKWatchedOutput output) {
11761 (self.register_output)(self.this_arg, output);
11763 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) {
11764 LDK::CResult_CoinSelectionNoneZ ret = (self.select_confirmed_utxos)(self.this_arg, claim_id, must_spend, must_pay_to, target_feerate_sat_per_1000_weight);
11767 inline LDK::CResult_TransactionNoneZ CoinSelectionSource::sign_psbt(struct LDKCVec_u8Z psbt) {
11768 LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
11771 inline LDK::CResult_CVec_UtxoZNoneZ WalletSource::list_confirmed_utxos() {
11772 LDK::CResult_CVec_UtxoZNoneZ ret = (self.list_confirmed_utxos)(self.this_arg);
11775 inline LDK::CResult_CVec_u8ZNoneZ WalletSource::get_change_script() {
11776 LDK::CResult_CVec_u8ZNoneZ ret = (self.get_change_script)(self.this_arg);
11779 inline LDK::CResult_TransactionNoneZ WalletSource::sign_psbt(struct LDKCVec_u8Z psbt) {
11780 LDK::CResult_TransactionNoneZ ret = (self.sign_psbt)(self.this_arg, psbt);
11783 inline LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ EcdsaChannelSigner::sign_counterparty_commitment(const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_ThirtyTwoBytesZ inbound_htlc_preimages, struct LDKCVec_ThirtyTwoBytesZ outbound_htlc_preimages) {
11784 LDK::CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret = (self.sign_counterparty_commitment)(self.this_arg, commitment_tx, inbound_htlc_preimages, outbound_htlc_preimages);
11787 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_commitment(const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx) {
11788 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_commitment)(self.this_arg, commitment_tx);
11791 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]) {
11792 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_output)(self.this_arg, justice_tx, input, amount, per_commitment_key);
11795 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) {
11796 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_justice_revoked_htlc)(self.this_arg, justice_tx, input, amount, per_commitment_key, htlc);
11799 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_htlc_transaction(struct LDKTransaction htlc_tx, uintptr_t input, const struct LDKHTLCDescriptor *NONNULL_PTR htlc_descriptor) {
11800 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_htlc_transaction)(self.this_arg, htlc_tx, input, htlc_descriptor);
11803 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) {
11804 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_counterparty_htlc_transaction)(self.this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
11807 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_closing_transaction(const struct LDKClosingTransaction *NONNULL_PTR closing_tx) {
11808 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_closing_transaction)(self.this_arg, closing_tx);
11811 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_holder_anchor_input(struct LDKTransaction anchor_tx, uintptr_t input) {
11812 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_holder_anchor_input)(self.this_arg, anchor_tx, input);
11815 inline LDK::CResult_ECDSASignatureNoneZ EcdsaChannelSigner::sign_channel_announcement_with_funding_key(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg) {
11816 LDK::CResult_ECDSASignatureNoneZ ret = (self.sign_channel_announcement_with_funding_key)(self.this_arg, msg);
11819 inline LDK::CResult_NoneLightningErrorZ CustomMessageHandler::handle_custom_message(struct LDKType msg, struct LDKPublicKey sender_node_id) {
11820 LDK::CResult_NoneLightningErrorZ ret = (self.handle_custom_message)(self.this_arg, msg, sender_node_id);
11823 inline LDK::CVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler::get_and_clear_pending_msg() {
11824 LDK::CVec_C2Tuple_PublicKeyTypeZZ ret = (self.get_and_clear_pending_msg)(self.this_arg);
11827 inline LDK::NodeFeatures CustomMessageHandler::provided_node_features() {
11828 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11831 inline LDK::InitFeatures CustomMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11832 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11835 inline uintptr_t SocketDescriptor::send_data(struct LDKu8slice data, bool resume_read) {
11836 uintptr_t ret = (self.send_data)(self.this_arg, data, resume_read);
11839 inline void SocketDescriptor::disconnect_socket() {
11840 (self.disconnect_socket)(self.this_arg);
11842 inline bool SocketDescriptor::eq(const struct LDKSocketDescriptor *NONNULL_PTR other_arg) {
11843 bool ret = (self.eq)(self.this_arg, other_arg);
11846 inline uint64_t SocketDescriptor::hash() {
11847 uint64_t ret = (self.hash)(self.this_arg);
11850 inline LDK::CResult_CVec_u8ZIOErrorZ KVStore::read(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key) {
11851 LDK::CResult_CVec_u8ZIOErrorZ ret = (self.read)(self.this_arg, primary_namespace, secondary_namespace, key);
11854 inline LDK::CResult_NoneIOErrorZ KVStore::write(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, struct LDKu8slice buf) {
11855 LDK::CResult_NoneIOErrorZ ret = (self.write)(self.this_arg, primary_namespace, secondary_namespace, key, buf);
11858 inline LDK::CResult_NoneIOErrorZ KVStore::remove(struct LDKStr primary_namespace, struct LDKStr secondary_namespace, struct LDKStr key, bool lazy) {
11859 LDK::CResult_NoneIOErrorZ ret = (self.remove)(self.this_arg, primary_namespace, secondary_namespace, key, lazy);
11862 inline LDK::CResult_CVec_StrZIOErrorZ KVStore::list(struct LDKStr primary_namespace, struct LDKStr secondary_namespace) {
11863 LDK::CResult_CVec_StrZIOErrorZ ret = (self.list)(self.this_arg, primary_namespace, secondary_namespace);
11866 inline LDK::CResult_NoneIOErrorZ Persister::persist_manager(const struct LDKChannelManager *NONNULL_PTR channel_manager) {
11867 LDK::CResult_NoneIOErrorZ ret = (self.persist_manager)(self.this_arg, channel_manager);
11870 inline LDK::CResult_NoneIOErrorZ Persister::persist_graph(const struct LDKNetworkGraph *NONNULL_PTR network_graph) {
11871 LDK::CResult_NoneIOErrorZ ret = (self.persist_graph)(self.this_arg, network_graph);
11874 inline LDK::CResult_NoneIOErrorZ Persister::persist_scorer(const struct LDKWriteableScore *NONNULL_PTR scorer) {
11875 LDK::CResult_NoneIOErrorZ ret = (self.persist_scorer)(self.this_arg, scorer);
11878 inline void ChannelMessageHandler::handle_open_channel(struct LDKPublicKey their_node_id, const struct LDKOpenChannel *NONNULL_PTR msg) {
11879 (self.handle_open_channel)(self.this_arg, their_node_id, msg);
11881 inline void ChannelMessageHandler::handle_open_channel_v2(struct LDKPublicKey their_node_id, const struct LDKOpenChannelV2 *NONNULL_PTR msg) {
11882 (self.handle_open_channel_v2)(self.this_arg, their_node_id, msg);
11884 inline void ChannelMessageHandler::handle_accept_channel(struct LDKPublicKey their_node_id, const struct LDKAcceptChannel *NONNULL_PTR msg) {
11885 (self.handle_accept_channel)(self.this_arg, their_node_id, msg);
11887 inline void ChannelMessageHandler::handle_accept_channel_v2(struct LDKPublicKey their_node_id, const struct LDKAcceptChannelV2 *NONNULL_PTR msg) {
11888 (self.handle_accept_channel_v2)(self.this_arg, their_node_id, msg);
11890 inline void ChannelMessageHandler::handle_funding_created(struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg) {
11891 (self.handle_funding_created)(self.this_arg, their_node_id, msg);
11893 inline void ChannelMessageHandler::handle_funding_signed(struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg) {
11894 (self.handle_funding_signed)(self.this_arg, their_node_id, msg);
11896 inline void ChannelMessageHandler::handle_channel_ready(struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg) {
11897 (self.handle_channel_ready)(self.this_arg, their_node_id, msg);
11899 inline void ChannelMessageHandler::handle_shutdown(struct LDKPublicKey their_node_id, const struct LDKShutdown *NONNULL_PTR msg) {
11900 (self.handle_shutdown)(self.this_arg, their_node_id, msg);
11902 inline void ChannelMessageHandler::handle_closing_signed(struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg) {
11903 (self.handle_closing_signed)(self.this_arg, their_node_id, msg);
11905 inline void ChannelMessageHandler::handle_stfu(struct LDKPublicKey their_node_id, const struct LDKStfu *NONNULL_PTR msg) {
11906 (self.handle_stfu)(self.this_arg, their_node_id, msg);
11908 inline void ChannelMessageHandler::handle_splice(struct LDKPublicKey their_node_id, const struct LDKSplice *NONNULL_PTR msg) {
11909 (self.handle_splice)(self.this_arg, their_node_id, msg);
11911 inline void ChannelMessageHandler::handle_splice_ack(struct LDKPublicKey their_node_id, const struct LDKSpliceAck *NONNULL_PTR msg) {
11912 (self.handle_splice_ack)(self.this_arg, their_node_id, msg);
11914 inline void ChannelMessageHandler::handle_splice_locked(struct LDKPublicKey their_node_id, const struct LDKSpliceLocked *NONNULL_PTR msg) {
11915 (self.handle_splice_locked)(self.this_arg, their_node_id, msg);
11917 inline void ChannelMessageHandler::handle_tx_add_input(struct LDKPublicKey their_node_id, const struct LDKTxAddInput *NONNULL_PTR msg) {
11918 (self.handle_tx_add_input)(self.this_arg, their_node_id, msg);
11920 inline void ChannelMessageHandler::handle_tx_add_output(struct LDKPublicKey their_node_id, const struct LDKTxAddOutput *NONNULL_PTR msg) {
11921 (self.handle_tx_add_output)(self.this_arg, their_node_id, msg);
11923 inline void ChannelMessageHandler::handle_tx_remove_input(struct LDKPublicKey their_node_id, const struct LDKTxRemoveInput *NONNULL_PTR msg) {
11924 (self.handle_tx_remove_input)(self.this_arg, their_node_id, msg);
11926 inline void ChannelMessageHandler::handle_tx_remove_output(struct LDKPublicKey their_node_id, const struct LDKTxRemoveOutput *NONNULL_PTR msg) {
11927 (self.handle_tx_remove_output)(self.this_arg, their_node_id, msg);
11929 inline void ChannelMessageHandler::handle_tx_complete(struct LDKPublicKey their_node_id, const struct LDKTxComplete *NONNULL_PTR msg) {
11930 (self.handle_tx_complete)(self.this_arg, their_node_id, msg);
11932 inline void ChannelMessageHandler::handle_tx_signatures(struct LDKPublicKey their_node_id, const struct LDKTxSignatures *NONNULL_PTR msg) {
11933 (self.handle_tx_signatures)(self.this_arg, their_node_id, msg);
11935 inline void ChannelMessageHandler::handle_tx_init_rbf(struct LDKPublicKey their_node_id, const struct LDKTxInitRbf *NONNULL_PTR msg) {
11936 (self.handle_tx_init_rbf)(self.this_arg, their_node_id, msg);
11938 inline void ChannelMessageHandler::handle_tx_ack_rbf(struct LDKPublicKey their_node_id, const struct LDKTxAckRbf *NONNULL_PTR msg) {
11939 (self.handle_tx_ack_rbf)(self.this_arg, their_node_id, msg);
11941 inline void ChannelMessageHandler::handle_tx_abort(struct LDKPublicKey their_node_id, const struct LDKTxAbort *NONNULL_PTR msg) {
11942 (self.handle_tx_abort)(self.this_arg, their_node_id, msg);
11944 inline void ChannelMessageHandler::handle_update_add_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg) {
11945 (self.handle_update_add_htlc)(self.this_arg, their_node_id, msg);
11947 inline void ChannelMessageHandler::handle_update_fulfill_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg) {
11948 (self.handle_update_fulfill_htlc)(self.this_arg, their_node_id, msg);
11950 inline void ChannelMessageHandler::handle_update_fail_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg) {
11951 (self.handle_update_fail_htlc)(self.this_arg, their_node_id, msg);
11953 inline void ChannelMessageHandler::handle_update_fail_malformed_htlc(struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg) {
11954 (self.handle_update_fail_malformed_htlc)(self.this_arg, their_node_id, msg);
11956 inline void ChannelMessageHandler::handle_commitment_signed(struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg) {
11957 (self.handle_commitment_signed)(self.this_arg, their_node_id, msg);
11959 inline void ChannelMessageHandler::handle_revoke_and_ack(struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg) {
11960 (self.handle_revoke_and_ack)(self.this_arg, their_node_id, msg);
11962 inline void ChannelMessageHandler::handle_update_fee(struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg) {
11963 (self.handle_update_fee)(self.this_arg, their_node_id, msg);
11965 inline void ChannelMessageHandler::handle_announcement_signatures(struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg) {
11966 (self.handle_announcement_signatures)(self.this_arg, their_node_id, msg);
11968 inline void ChannelMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
11969 (self.peer_disconnected)(self.this_arg, their_node_id);
11971 inline LDK::CResult_NoneNoneZ ChannelMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg, bool inbound) {
11972 LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, msg, inbound);
11975 inline void ChannelMessageHandler::handle_channel_reestablish(struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg) {
11976 (self.handle_channel_reestablish)(self.this_arg, their_node_id, msg);
11978 inline void ChannelMessageHandler::handle_channel_update(struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg) {
11979 (self.handle_channel_update)(self.this_arg, their_node_id, msg);
11981 inline void ChannelMessageHandler::handle_error(struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg) {
11982 (self.handle_error)(self.this_arg, their_node_id, msg);
11984 inline LDK::NodeFeatures ChannelMessageHandler::provided_node_features() {
11985 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
11988 inline LDK::InitFeatures ChannelMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
11989 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
11992 inline LDK::COption_CVec_ThirtyTwoBytesZZ ChannelMessageHandler::get_chain_hashes() {
11993 LDK::COption_CVec_ThirtyTwoBytesZZ ret = (self.get_chain_hashes)(self.this_arg);
11996 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_node_announcement(const struct LDKNodeAnnouncement *NONNULL_PTR msg) {
11997 LDK::CResult_boolLightningErrorZ ret = (self.handle_node_announcement)(self.this_arg, msg);
12000 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_announcement(const struct LDKChannelAnnouncement *NONNULL_PTR msg) {
12001 LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_announcement)(self.this_arg, msg);
12004 inline LDK::CResult_boolLightningErrorZ RoutingMessageHandler::handle_channel_update(const struct LDKChannelUpdate *NONNULL_PTR msg) {
12005 LDK::CResult_boolLightningErrorZ ret = (self.handle_channel_update)(self.this_arg, msg);
12008 inline LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler::get_next_channel_announcement(uint64_t starting_point) {
12009 LDK::COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = (self.get_next_channel_announcement)(self.this_arg, starting_point);
12012 inline LDK::NodeAnnouncement RoutingMessageHandler::get_next_node_announcement(struct LDKNodeId starting_point) {
12013 LDK::NodeAnnouncement ret = (self.get_next_node_announcement)(self.this_arg, starting_point);
12016 inline LDK::CResult_NoneNoneZ RoutingMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
12017 LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
12020 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_channel_range(struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg) {
12021 LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_channel_range)(self.this_arg, their_node_id, msg);
12024 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_reply_short_channel_ids_end(struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg) {
12025 LDK::CResult_NoneLightningErrorZ ret = (self.handle_reply_short_channel_ids_end)(self.this_arg, their_node_id, msg);
12028 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_channel_range(struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg) {
12029 LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_channel_range)(self.this_arg, their_node_id, msg);
12032 inline LDK::CResult_NoneLightningErrorZ RoutingMessageHandler::handle_query_short_channel_ids(struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg) {
12033 LDK::CResult_NoneLightningErrorZ ret = (self.handle_query_short_channel_ids)(self.this_arg, their_node_id, msg);
12036 inline bool RoutingMessageHandler::processing_queue_high() {
12037 bool ret = (self.processing_queue_high)(self.this_arg);
12040 inline LDK::NodeFeatures RoutingMessageHandler::provided_node_features() {
12041 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
12044 inline LDK::InitFeatures RoutingMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
12045 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
12048 inline LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ OnionMessageHandler::get_and_clear_connections_needed() {
12049 LDK::CVec_C2Tuple_PublicKeyCVec_SocketAddressZZZ ret = (self.get_and_clear_connections_needed)(self.this_arg);
12052 inline void OnionMessageHandler::handle_onion_message(struct LDKPublicKey peer_node_id, const struct LDKOnionMessage *NONNULL_PTR msg) {
12053 (self.handle_onion_message)(self.this_arg, peer_node_id, msg);
12055 inline LDK::OnionMessage OnionMessageHandler::next_onion_message_for_peer(struct LDKPublicKey peer_node_id) {
12056 LDK::OnionMessage ret = (self.next_onion_message_for_peer)(self.this_arg, peer_node_id);
12059 inline LDK::CResult_NoneNoneZ OnionMessageHandler::peer_connected(struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init, bool inbound) {
12060 LDK::CResult_NoneNoneZ ret = (self.peer_connected)(self.this_arg, their_node_id, init, inbound);
12063 inline void OnionMessageHandler::peer_disconnected(struct LDKPublicKey their_node_id) {
12064 (self.peer_disconnected)(self.this_arg, their_node_id);
12066 inline void OnionMessageHandler::timer_tick_occurred() {
12067 (self.timer_tick_occurred)(self.this_arg);
12069 inline LDK::NodeFeatures OnionMessageHandler::provided_node_features() {
12070 LDK::NodeFeatures ret = (self.provided_node_features)(self.this_arg);
12073 inline LDK::InitFeatures OnionMessageHandler::provided_init_features(struct LDKPublicKey their_node_id) {
12074 LDK::InitFeatures ret = (self.provided_init_features)(self.this_arg, their_node_id);
12077 inline void Logger::log(struct LDKRecord record) {
12078 (self.log)(self.this_arg, record);
12080 inline void FutureCallback::call() {
12081 (self.call)(self.this_arg);
12083 inline LDK::COption_OffersMessageZ OffersMessageHandler::handle_message(struct LDKOffersMessage message) {
12084 LDK::COption_OffersMessageZ ret = (self.handle_message)(self.this_arg, message);
12087 inline LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ OffersMessageHandler::release_pending_messages() {
12088 LDK::CVec_C3Tuple_OffersMessageDestinationBlindedPathZZ ret = (self.release_pending_messages)(self.this_arg);
12091 inline void BroadcasterInterface::broadcast_transactions(struct LDKCVec_TransactionZ txs) {
12092 (self.broadcast_transactions)(self.this_arg, txs);
12094 inline uint32_t FeeEstimator::get_est_sat_per_1000_weight(enum LDKConfirmationTarget confirmation_target) {
12095 uint32_t ret = (self.get_est_sat_per_1000_weight)(self.this_arg, confirmation_target);
12098 inline uint64_t OnionMessageContents::tlv_type() {
12099 uint64_t ret = (self.tlv_type)(self.this_arg);
12102 inline LDK::Str OnionMessageContents::debug_str() {
12103 LDK::Str ret = (self.debug_str)(self.this_arg);
12106 inline LDK::CVec_MessageSendEventZ MessageSendEventsProvider::get_and_clear_pending_msg_events() {
12107 LDK::CVec_MessageSendEventZ ret = (self.get_and_clear_pending_msg_events)(self.this_arg);
12110 inline void EventsProvider::process_pending_events(struct LDKEventHandler handler) {
12111 (self.process_pending_events)(self.this_arg, handler);
12113 inline void EventHandler::handle_event(struct LDKEvent event) {
12114 (self.handle_event)(self.this_arg, event);
12116 inline LDK::CResult_COption_TypeZDecodeErrorZ CustomMessageReader::read(uint16_t message_type, struct LDKu8slice buffer) {
12117 LDK::CResult_COption_TypeZDecodeErrorZ ret = (self.read)(self.this_arg, message_type, buffer);
12120 inline uint16_t Type::type_id() {
12121 uint16_t ret = (self.type_id)(self.this_arg);
12124 inline LDK::Str Type::debug_str() {
12125 LDK::Str ret = (self.debug_str)(self.this_arg);
12128 inline LDK::UtxoResult UtxoLookup::get_utxo(const uint8_t (*chain_hash)[32], uint64_t short_channel_id) {
12129 LDK::UtxoResult ret = (self.get_utxo)(self.this_arg, chain_hash, short_channel_id);
12132 inline LDK::CResult_OnionMessagePathNoneZ MessageRouter::find_path(struct LDKPublicKey sender, struct LDKCVec_PublicKeyZ peers, struct LDKDestination destination) {
12133 LDK::CResult_OnionMessagePathNoneZ ret = (self.find_path)(self.this_arg, sender, peers, destination);
12136 inline LDK::CResult_CVec_BlindedPathZNoneZ MessageRouter::create_blinded_paths(struct LDKPublicKey recipient, struct LDKCVec_PublicKeyZ peers) {
12137 LDK::CResult_CVec_BlindedPathZNoneZ ret = (self.create_blinded_paths)(self.this_arg, recipient, peers);
12140 inline LDK::COption_OnionMessageContentsZ CustomOnionMessageHandler::handle_custom_message(struct LDKOnionMessageContents msg) {
12141 LDK::COption_OnionMessageContentsZ ret = (self.handle_custom_message)(self.this_arg, msg);
12144 inline LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ CustomOnionMessageHandler::read_custom_message(uint64_t message_type, struct LDKu8slice buffer) {
12145 LDK::CResult_COption_OnionMessageContentsZDecodeErrorZ ret = (self.read_custom_message)(self.this_arg, message_type, buffer);
12148 inline LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ CustomOnionMessageHandler::release_pending_custom_messages() {
12149 LDK::CVec_C3Tuple_OnionMessageContentsDestinationBlindedPathZZ ret = (self.release_pending_custom_messages)(self.this_arg);
12152 inline LDK::ChannelMonitorUpdateStatus Persist::persist_new_channel(struct LDKOutPoint channel_id, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
12153 LDK::ChannelMonitorUpdateStatus ret = (self.persist_new_channel)(self.this_arg, channel_id, data, update_id);
12156 inline LDK::ChannelMonitorUpdateStatus Persist::update_persisted_channel(struct LDKOutPoint channel_id, struct LDKChannelMonitorUpdate update, const struct LDKChannelMonitor *NONNULL_PTR data, struct LDKMonitorUpdateId update_id) {
12157 LDK::ChannelMonitorUpdateStatus ret = (self.update_persisted_channel)(self.this_arg, channel_id, update, data, update_id);