All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| AcceptChannel |
An [`accept_channel`] message to be sent to or received from a peer.
|
| Amount |
The minimum amount required for an item in an [`Offer`], denominated in either bitcoin or
another currency.
|
| AnnouncementSignatures |
An [`announcement_signatures`] message to be sent to or received from a peer.
|
| APIError |
Indicates an error on the client's part (usually some variant of attempting to use too-low or
too-high values)
|
| APIError.APIMisuseError |
Indicates the API was wholly misused (see err for more).
|
| APIError.ChannelUnavailable |
We were unable to complete the request as the Channel required to do so is unable to
complete the request (or was not found).
|
| APIError.FeeRateTooHigh |
Due to a high feerate, we were unable to complete the request.
|
| APIError.IncompatibleShutdownScript |
[`SignerProvider::get_shutdown_scriptpubkey`] returned a shutdown scriptpubkey incompatible
with the channel counterparty as negotiated in [`InitFeatures`].
|
| APIError.InvalidRoute |
A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route,
too-many-hops, etc).
|
| APIError.MonitorUpdateInProgress |
An attempt to call [`chain::Watch::watch_channel`]/[`chain::Watch::update_channel`]
returned a [`ChannelMonitorUpdateStatus::InProgress`] indicating the persistence of a
monitor update is awaiting async resolution.
|
| BackgroundProcessor |
`BackgroundProcessor` takes care of tasks that (1) need to happen periodically to keep
Rust-Lightning running properly, and (2) either can or should be run in the background.
|
| Balance |
Details about the balance(s) available for spending once the channel appears on chain.
|
| Balance.ClaimableAwaitingConfirmations |
The channel has been closed, and the given balance is ours but awaiting confirmations until
we consider it spendable.
|
| Balance.ClaimableOnChannelClose |
The channel is not yet closed (or the commitment or closing transaction has not yet
appeared in a block).
|
| Balance.ContentiousClaimable |
The channel has been closed, and the given balance should be ours but awaiting spending
transaction confirmation.
|
| Balance.CounterpartyRevokedOutputClaimable |
The channel has been closed, and our counterparty broadcasted a revoked commitment
transaction.
|
| Balance.MaybePreimageClaimableHTLC |
HTLCs which we received from our counterparty which are claimable with a preimage which we
do not currently have.
|
| Balance.MaybeTimeoutClaimableHTLC |
HTLCs which we sent to our counterparty which are claimable after a timeout (less on-chain
fees) if the counterparty does not know the preimage for the HTLCs.
|
| Bech32Error |
Represents an error returned from the bech32 library during validation of some bech32 data
|
| Bech32Error.InvalidChar |
Some part of the string contains an invalid character
|
| Bech32Error.InvalidChecksum |
The checksum does not match the rest of the data
|
| Bech32Error.InvalidData |
Some part of the data has an invalid value
|
| Bech32Error.InvalidLength |
The data or human-readable part is too long or too short
|
| Bech32Error.InvalidPadding |
The bit conversion failed due to a padding issue
|
| Bech32Error.MissingSeparator |
String does not contain the separator character
|
| Bech32Error.MixedCase |
The whole string must be of one case
|
| BestBlock |
The best known block as identified by its hash and height.
|
| BigEndianScalar |
|
| BigSize |
Lightning TLV uses a custom variable-length integer called `BigSize`.
|
| bindings |
|
| bindings.LDKAPIError |
|
| bindings.LDKAPIError.APIMisuseError |
|
| bindings.LDKAPIError.ChannelUnavailable |
|
| bindings.LDKAPIError.FeeRateTooHigh |
|
| bindings.LDKAPIError.IncompatibleShutdownScript |
|
| bindings.LDKAPIError.InvalidRoute |
|
| bindings.LDKAPIError.MonitorUpdateInProgress |
|
| bindings.LDKBalance |
|
| bindings.LDKBalance.ClaimableAwaitingConfirmations |
|
| bindings.LDKBalance.ClaimableOnChannelClose |
|
| bindings.LDKBalance.ContentiousClaimable |
|
| bindings.LDKBalance.CounterpartyRevokedOutputClaimable |
|
| bindings.LDKBalance.MaybePreimageClaimableHTLC |
|
| bindings.LDKBalance.MaybeTimeoutClaimableHTLC |
|
| bindings.LDKBech32Error |
|
| bindings.LDKBech32Error.InvalidChar |
|
| bindings.LDKBech32Error.InvalidChecksum |
|
| bindings.LDKBech32Error.InvalidData |
|
| bindings.LDKBech32Error.InvalidLength |
|
| bindings.LDKBech32Error.InvalidPadding |
|
| bindings.LDKBech32Error.MissingSeparator |
|
| bindings.LDKBech32Error.MixedCase |
|
| bindings.LDKBroadcasterInterface |
|
| bindings.LDKChannelMessageHandler |
|
| bindings.LDKChannelSigner |
|
| bindings.LDKClosureReason |
|
| bindings.LDKClosureReason.CommitmentTxConfirmed |
|
| bindings.LDKClosureReason.CooperativeClosure |
|
| bindings.LDKClosureReason.CounterpartyForceClosed |
|
| bindings.LDKClosureReason.DisconnectedPeer |
|
| bindings.LDKClosureReason.FundingTimedOut |
|
| bindings.LDKClosureReason.HolderForceClosed |
|
| bindings.LDKClosureReason.OutdatedChannelManager |
|
| bindings.LDKClosureReason.ProcessingError |
|
| bindings.LDKConfirm |
|
| bindings.LDKCOption_APIErrorZ |
|
| bindings.LDKCOption_APIErrorZ.None |
|
| bindings.LDKCOption_APIErrorZ.Some |
|
| bindings.LDKCOption_C2Tuple_EightU16sEightU16sZZ |
|
| bindings.LDKCOption_C2Tuple_EightU16sEightU16sZZ.None |
|
| bindings.LDKCOption_C2Tuple_EightU16sEightU16sZZ.Some |
|
| bindings.LDKCOption_C2Tuple_u64u64ZZ |
|
| bindings.LDKCOption_C2Tuple_u64u64ZZ.None |
|
| bindings.LDKCOption_C2Tuple_u64u64ZZ.Some |
|
| bindings.LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ |
|
| bindings.LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ.None |
|
| bindings.LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ.Some |
|
| bindings.LDKCOption_ClosureReasonZ |
|
| bindings.LDKCOption_ClosureReasonZ.None |
|
| bindings.LDKCOption_ClosureReasonZ.Some |
|
| bindings.LDKCOption_CustomOnionMessageContentsZ |
|
| bindings.LDKCOption_CustomOnionMessageContentsZ.None |
|
| bindings.LDKCOption_CustomOnionMessageContentsZ.Some |
|
| bindings.LDKCOption_CVec_NetAddressZZ |
|
| bindings.LDKCOption_CVec_NetAddressZZ.None |
|
| bindings.LDKCOption_CVec_NetAddressZZ.Some |
|
| bindings.LDKCOption_CVec_u8ZZ |
|
| bindings.LDKCOption_CVec_u8ZZ.None |
|
| bindings.LDKCOption_CVec_u8ZZ.Some |
|
| bindings.LDKCOption_DurationZ |
|
| bindings.LDKCOption_DurationZ.None |
|
| bindings.LDKCOption_DurationZ.Some |
|
| bindings.LDKCOption_EventZ |
|
| bindings.LDKCOption_EventZ.None |
|
| bindings.LDKCOption_EventZ.Some |
|
| bindings.LDKCOption_FilterZ |
|
| bindings.LDKCOption_FilterZ.None |
|
| bindings.LDKCOption_FilterZ.Some |
|
| bindings.LDKCOption_HTLCClaimZ |
|
| bindings.LDKCOption_HTLCClaimZ.None |
|
| bindings.LDKCOption_HTLCClaimZ.Some |
|
| bindings.LDKCOption_HTLCDestinationZ |
|
| bindings.LDKCOption_HTLCDestinationZ.None |
|
| bindings.LDKCOption_HTLCDestinationZ.Some |
|
| bindings.LDKCOption_MonitorEventZ |
|
| bindings.LDKCOption_MonitorEventZ.None |
|
| bindings.LDKCOption_MonitorEventZ.Some |
|
| bindings.LDKCOption_NetAddressZ |
|
| bindings.LDKCOption_NetAddressZ.None |
|
| bindings.LDKCOption_NetAddressZ.Some |
|
| bindings.LDKCOption_NetworkUpdateZ |
|
| bindings.LDKCOption_NetworkUpdateZ.None |
|
| bindings.LDKCOption_NetworkUpdateZ.Some |
|
| bindings.LDKCOption_PathFailureZ |
|
| bindings.LDKCOption_PathFailureZ.None |
|
| bindings.LDKCOption_PathFailureZ.Some |
|
| bindings.LDKCOption_PaymentFailureReasonZ |
|
| bindings.LDKCOption_PaymentFailureReasonZ.None |
|
| bindings.LDKCOption_PaymentFailureReasonZ.Some |
|
| bindings.LDKCOption_ScalarZ |
|
| bindings.LDKCOption_ScalarZ.None |
|
| bindings.LDKCOption_ScalarZ.Some |
|
| bindings.LDKCOption_TypeZ |
|
| bindings.LDKCOption_TypeZ.None |
|
| bindings.LDKCOption_TypeZ.Some |
|
| bindings.LDKCOption_u128Z |
|
| bindings.LDKCOption_u128Z.None |
|
| bindings.LDKCOption_u128Z.Some |
|
| bindings.LDKCOption_u16Z |
|
| bindings.LDKCOption_u16Z.None |
|
| bindings.LDKCOption_u16Z.Some |
|
| bindings.LDKCOption_u32Z |
|
| bindings.LDKCOption_u32Z.None |
|
| bindings.LDKCOption_u32Z.Some |
|
| bindings.LDKCOption_u64Z |
|
| bindings.LDKCOption_u64Z.None |
|
| bindings.LDKCOption_u64Z.Some |
|
| bindings.LDKCOption_UtxoLookupZ |
|
| bindings.LDKCOption_UtxoLookupZ.None |
|
| bindings.LDKCOption_UtxoLookupZ.Some |
|
| bindings.LDKCOption_WriteableScoreZ |
|
| bindings.LDKCOption_WriteableScoreZ.None |
|
| bindings.LDKCOption_WriteableScoreZ.Some |
|
| bindings.LDKCustomMessageHandler |
|
| bindings.LDKCustomMessageReader |
|
| bindings.LDKCustomOnionMessageContents |
|
| bindings.LDKCustomOnionMessageHandler |
|
| bindings.LDKDecodeError |
|
| bindings.LDKDecodeError.BadLengthDescriptor |
|
| bindings.LDKDecodeError.InvalidValue |
|
| bindings.LDKDecodeError.Io |
|
| bindings.LDKDecodeError.ShortRead |
|
| bindings.LDKDecodeError.UnknownRequiredFeature |
|
| bindings.LDKDecodeError.UnknownVersion |
|
| bindings.LDKDecodeError.UnsupportedCompression |
|
| bindings.LDKDestination |
|
| bindings.LDKDestination.BlindedPath |
|
| bindings.LDKDestination.Node |
|
| bindings.LDKEcdsaChannelSigner |
|
| bindings.LDKEffectiveCapacity |
|
| bindings.LDKEffectiveCapacity.ExactLiquidity |
|
| bindings.LDKEffectiveCapacity.Infinite |
|
| bindings.LDKEffectiveCapacity.MaximumHTLC |
|
| bindings.LDKEffectiveCapacity.Total |
|
| bindings.LDKEffectiveCapacity.Unknown |
|
| bindings.LDKEntropySource |
|
| bindings.LDKErrorAction |
|
| bindings.LDKErrorAction.DisconnectPeer |
|
| bindings.LDKErrorAction.IgnoreAndLog |
|
| bindings.LDKErrorAction.IgnoreDuplicateGossip |
|
| bindings.LDKErrorAction.IgnoreError |
|
| bindings.LDKErrorAction.SendErrorMessage |
|
| bindings.LDKErrorAction.SendWarningMessage |
|
| bindings.LDKEvent |
|
| bindings.LDKEvent.ChannelClosed |
|
| bindings.LDKEvent.ChannelPending |
|
| bindings.LDKEvent.ChannelReady |
|
| bindings.LDKEvent.DiscardFunding |
|
| bindings.LDKEvent.FundingGenerationReady |
|
| bindings.LDKEvent.HTLCHandlingFailed |
|
| bindings.LDKEvent.HTLCIntercepted |
|
| bindings.LDKEvent.OpenChannelRequest |
|
| bindings.LDKEvent.PaymentClaimable |
|
| bindings.LDKEvent.PaymentClaimed |
|
| bindings.LDKEvent.PaymentFailed |
|
| bindings.LDKEvent.PaymentForwarded |
|
| bindings.LDKEvent.PaymentPathFailed |
|
| bindings.LDKEvent.PaymentPathSuccessful |
|
| bindings.LDKEvent.PaymentSent |
|
| bindings.LDKEvent.PendingHTLCsForwardable |
|
| bindings.LDKEvent.ProbeFailed |
|
| bindings.LDKEvent.ProbeSuccessful |
|
| bindings.LDKEvent.SpendableOutputs |
|
| bindings.LDKEventHandler |
|
| bindings.LDKEventsProvider |
|
| bindings.LDKFallback |
|
| bindings.LDKFallback.PubKeyHash |
|
| bindings.LDKFallback.ScriptHash |
|
| bindings.LDKFallback.SegWitProgram |
|
| bindings.LDKFeeEstimator |
|
| bindings.LDKFilter |
|
| bindings.LDKFutureCallback |
|
| bindings.LDKGossipSync |
|
| bindings.LDKGossipSync.None |
|
| bindings.LDKGossipSync.P2P |
|
| bindings.LDKGossipSync.Rapid |
|
| bindings.LDKGraphSyncError |
|
| bindings.LDKGraphSyncError.DecodeError |
|
| bindings.LDKGraphSyncError.LightningError |
|
| bindings.LDKHints |
|
| bindings.LDKHints.Blinded |
|
| bindings.LDKHints.Clear |
|
| bindings.LDKHTLCDestination |
|
| bindings.LDKHTLCDestination.FailedPayment |
|
| bindings.LDKHTLCDestination.InvalidForward |
|
| bindings.LDKHTLCDestination.NextHopChannel |
|
| bindings.LDKHTLCDestination.UnknownNextHop |
|
| bindings.LDKListen |
|
| bindings.LDKLockableScore |
|
| bindings.LDKLogger |
|
| bindings.LDKMessageSendEvent |
|
| bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement |
|
| bindings.LDKMessageSendEvent.BroadcastChannelUpdate |
|
| bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement |
|
| bindings.LDKMessageSendEvent.HandleError |
|
| bindings.LDKMessageSendEvent.SendAcceptChannel |
|
| bindings.LDKMessageSendEvent.SendAnnouncementSignatures |
|
| bindings.LDKMessageSendEvent.SendChannelAnnouncement |
|
| bindings.LDKMessageSendEvent.SendChannelRangeQuery |
|
| bindings.LDKMessageSendEvent.SendChannelReady |
|
| bindings.LDKMessageSendEvent.SendChannelReestablish |
|
| bindings.LDKMessageSendEvent.SendChannelUpdate |
|
| bindings.LDKMessageSendEvent.SendClosingSigned |
|
| bindings.LDKMessageSendEvent.SendFundingCreated |
|
| bindings.LDKMessageSendEvent.SendFundingSigned |
|
| bindings.LDKMessageSendEvent.SendGossipTimestampFilter |
|
| bindings.LDKMessageSendEvent.SendOpenChannel |
|
| bindings.LDKMessageSendEvent.SendReplyChannelRange |
|
| bindings.LDKMessageSendEvent.SendRevokeAndACK |
|
| bindings.LDKMessageSendEvent.SendShortIdsQuery |
|
| bindings.LDKMessageSendEvent.SendShutdown |
|
| bindings.LDKMessageSendEvent.UpdateHTLCs |
|
| bindings.LDKMessageSendEventsProvider |
|
| bindings.LDKMonitorEvent |
|
| bindings.LDKMonitorEvent.CommitmentTxConfirmed |
|
| bindings.LDKMonitorEvent.Completed |
|
| bindings.LDKMonitorEvent.HTLCEvent |
|
| bindings.LDKMonitorEvent.UpdateFailed |
|
| bindings.LDKNetAddress |
|
| bindings.LDKNetAddress.Hostname |
|
| bindings.LDKNetAddress.IPv4 |
|
| bindings.LDKNetAddress.IPv6 |
|
| bindings.LDKNetAddress.OnionV2 |
|
| bindings.LDKNetAddress.OnionV3 |
|
| bindings.LDKNetworkUpdate |
|
| bindings.LDKNetworkUpdate.ChannelFailure |
|
| bindings.LDKNetworkUpdate.ChannelUpdateMessage |
|
| bindings.LDKNetworkUpdate.NodeFailure |
|
| bindings.LDKNodeSigner |
|
| bindings.LDKOnionMessageContents |
|
| bindings.LDKOnionMessageContents.Custom |
|
| bindings.LDKOnionMessageHandler |
|
| bindings.LDKOnionMessageProvider |
|
| bindings.LDKParseError |
|
| bindings.LDKParseError.BadPrefix |
|
| bindings.LDKParseError.Bech32Error |
|
| bindings.LDKParseError.DescriptionDecodeError |
|
| bindings.LDKParseError.IntegerOverflowError |
|
| bindings.LDKParseError.InvalidPubKeyHashLength |
|
| bindings.LDKParseError.InvalidRecoveryId |
|
| bindings.LDKParseError.InvalidScriptHashLength |
|
| bindings.LDKParseError.InvalidSegWitProgramLength |
|
| bindings.LDKParseError.InvalidSliceLength |
|
| bindings.LDKParseError.MalformedHRP |
|
| bindings.LDKParseError.MalformedSignature |
|
| bindings.LDKParseError.PaddingError |
|
| bindings.LDKParseError.ParseAmountError |
|
| bindings.LDKParseError.Skip |
|
| bindings.LDKParseError.TooShortDataPart |
|
| bindings.LDKParseError.UnexpectedEndOfTaggedFields |
|
| bindings.LDKParseError.UnknownCurrency |
|
| bindings.LDKParseError.UnknownSiPrefix |
|
| bindings.LDKParseOrSemanticError |
|
| bindings.LDKParseOrSemanticError.ParseError |
|
| bindings.LDKParseOrSemanticError.SemanticError |
|
| bindings.LDKPathFailure |
|
| bindings.LDKPathFailure.InitialSend |
|
| bindings.LDKPathFailure.OnPath |
|
| bindings.LDKPaymentError |
|
| bindings.LDKPaymentError.Invoice |
|
| bindings.LDKPaymentError.Sending |
|
| bindings.LDKPaymentPurpose |
|
| bindings.LDKPaymentPurpose.InvoicePayment |
|
| bindings.LDKPaymentPurpose.SpontaneousPayment |
|
| bindings.LDKPaymentSendFailure |
|
| bindings.LDKPaymentSendFailure.AllFailedResendSafe |
|
| bindings.LDKPaymentSendFailure.DuplicatePayment |
|
| bindings.LDKPaymentSendFailure.ParameterError |
|
| bindings.LDKPaymentSendFailure.PartialFailure |
|
| bindings.LDKPaymentSendFailure.PathParameterError |
|
| bindings.LDKPersist |
|
| bindings.LDKPersister |
|
| bindings.LDKRecentPaymentDetails |
|
| bindings.LDKRecentPaymentDetails.Abandoned |
|
| bindings.LDKRecentPaymentDetails.Fulfilled |
|
| bindings.LDKRecentPaymentDetails.Pending |
|
| bindings.LDKRetry |
|
| bindings.LDKRetry.Attempts |
|
| bindings.LDKRetry.Timeout |
|
| bindings.LDKRouter |
|
| bindings.LDKRoutingMessageHandler |
|
| bindings.LDKScore |
|
| bindings.LDKSendError |
|
| bindings.LDKSendError.BlindedPathAdvanceFailed |
|
| bindings.LDKSendError.BufferFull |
|
| bindings.LDKSendError.GetNodeIdFailed |
|
| bindings.LDKSendError.InvalidFirstHop |
|
| bindings.LDKSendError.InvalidMessage |
|
| bindings.LDKSendError.Secp256k1 |
|
| bindings.LDKSendError.TooBigPacket |
|
| bindings.LDKSendError.TooFewBlindedHops |
|
| bindings.LDKSignerProvider |
|
| bindings.LDKSignOrCreationError |
|
| bindings.LDKSignOrCreationError.CreationError |
|
| bindings.LDKSignOrCreationError.SignError |
|
| bindings.LDKSocketDescriptor |
|
| bindings.LDKSpendableOutputDescriptor |
|
| bindings.LDKSpendableOutputDescriptor.DelayedPaymentOutput |
|
| bindings.LDKSpendableOutputDescriptor.StaticOutput |
|
| bindings.LDKSpendableOutputDescriptor.StaticPaymentOutput |
|
| bindings.LDKType |
|
| bindings.LDKUnsignedGossipMessage |
|
| bindings.LDKUnsignedGossipMessage.ChannelAnnouncement |
|
| bindings.LDKUnsignedGossipMessage.ChannelUpdate |
|
| bindings.LDKUnsignedGossipMessage.NodeAnnouncement |
|
| bindings.LDKUtxoLookup |
|
| bindings.LDKUtxoResult |
|
| bindings.LDKUtxoResult.Async |
|
| bindings.LDKUtxoResult.Sync |
|
| bindings.LDKWatch |
|
| bindings.LDKWriteableEcdsaChannelSigner |
|
| bindings.LDKWriteableScore |
|
| BlindedHop |
Used to construct the blinded hops portion of a blinded path.
|
| BlindedHopFeatures |
Features used within BOLT 4 encrypted_data_tlv and BOLT 12 blinded_payinfo
|
| BlindedPath |
Onion messages and payments can be sent and received to blinded paths, which serve to hide the
identity of the recipient.
|
| BlindedPayInfo |
Information needed to route a payment across a [`BlindedPath`].
|
| BlindedTail |
The blinded portion of a [`Path`], if we're routing to a recipient who provided blinded paths in
their BOLT12 [`Invoice`].
|
| Bolt12InvoiceFeatures |
Features used within an `invoice`.
|
| BroadcasterInterface |
An interface to send a transaction to the Bitcoin network.
|
| BroadcasterInterface.BroadcasterInterfaceInterface |
|
| BuiltCommitmentTransaction |
A pre-built Bitcoin commitment transaction and its txid.
|
| ChainMonitor |
An implementation of [`chain::Watch`] for monitoring channels.
|
| ChainParameters |
Chain-related parameters used to construct a new `ChannelManager`.
|
| ChannelAnnouncement |
A [`channel_announcement`] message to be sent to or received from a peer.
|
| ChannelConfig |
Options which apply on a per-channel basis and may change at runtime or based on negotiation
with our counterparty.
|
| ChannelCounterparty |
Channel parameters which apply to our counterparty.
|
| ChannelDetails |
Details of a channel, as returned by [`ChannelManager::list_channels`] and [`ChannelManager::list_usable_channels`]
|
| ChannelFeatures |
Features used within a `channel_announcement` message.
|
| ChannelHandshakeConfig |
Configuration we set when applicable.
|
| ChannelHandshakeLimits |
Optional channel limits which are applied during channel creation.
|
| ChannelInfo |
Details about a channel (both directions).
|
| ChannelManager |
Manager which keeps track of a number of channels and sends messages to the appropriate
channel, also tracking HTLC preimages and forwarding onion packets appropriately.
|
| ChannelManagerConstructor |
A simple utility class which assists in constructing a fresh or deserializing from disk a ChannelManager and one or
more ChannelMonitors.
|
| ChannelManagerConstructor.EventHandler |
Abstract interface which should handle Events and persist the ChannelManager.
|
| ChannelManagerConstructor.InvalidSerializedDataException |
An Exception that indicates the serialized data is invalid and has been corrupted on disk.
|
| ChannelManagerConstructor.RouterWrapper |
A simple interface to provide routes to LDK.
|
| ChannelManagerReadArgs |
Arguments for the creation of a ChannelManager that are not deserialized.
|
| ChannelMessageHandler |
A trait to describe an object which can receive channel messages.
|
| ChannelMessageHandler.ChannelMessageHandlerInterface |
|
| ChannelMonitor |
A ChannelMonitor handles chain events (blocks connected and disconnected) and generates
on-chain transactions to ensure no loss of funds occurs.
|
| ChannelMonitorUpdate |
An update generated by the underlying channel itself which contains some new information the
[`ChannelMonitor`] should be made aware of.
|
| ChannelMonitorUpdateStatus |
An enum representing the status of a channel monitor update persistence.
|
| ChannelPublicKeys |
One counterparty's public keys which do not change over the life of a channel.
|
| ChannelReady |
A [`channel_ready`] message to be sent to or received from a peer.
|
| ChannelReestablish |
A [`channel_reestablish`] message to be sent to or received from a peer.
|
| ChannelSigner |
A trait to handle Lightning channel key material without concretizing the channel type or
the signature mechanism.
|
| ChannelSigner.ChannelSignerInterface |
|
| ChannelTransactionParameters |
Per-channel data used to build transactions in conjunction with the per-commitment data (CommitmentTransaction).
|
| ChannelTypeFeatures |
Features used within the channel_type field in an OpenChannel message.
|
| ChannelUpdate |
A [`channel_update`] message to be sent to or received from a peer.
|
| ChannelUpdateInfo |
Details about one direction of a channel as received within a [`ChannelUpdate`].
|
| ChannelUsage |
Proposed use of a channel passed as a parameter to [`Score::channel_penalty_msat`].
|
| ClosingSigned |
A [`closing_signed`] message to be sent to or received from a peer.
|
| ClosingSignedFeeRange |
The minimum and maximum fees which the sender is willing to place on the closing transaction.
|
| ClosingTransaction |
This class tracks the per-transaction information needed to build a closing transaction and will
actually build it and sign.
|
| ClosureReason |
The reason the channel was closed.
|
| ClosureReason.CommitmentTxConfirmed |
A commitment transaction was confirmed on chain, closing the channel.
|
| ClosureReason.CooperativeClosure |
The channel was closed after negotiating a cooperative close and we've now broadcasted
the cooperative close transaction.
|
| ClosureReason.CounterpartyForceClosed |
Closure generated from receiving a peer error message.
|
| ClosureReason.DisconnectedPeer |
The peer disconnected prior to funding completing.
|
| ClosureReason.FundingTimedOut |
The funding transaction failed to confirm in a timely manner on an inbound channel.
|
| ClosureReason.HolderForceClosed |
Closure generated from [`ChannelManager::force_close_channel`], called by the user.
|
| ClosureReason.OutdatedChannelManager |
Closure generated from `ChannelManager::read` if the [`ChannelMonitor`] is newer than
the [`ChannelManager`] deserialized.
|
| ClosureReason.ProcessingError |
Closure generated from processing an event, likely a HTLC forward/relay/reception.
|
| CommitmentSigned |
A [`commitment_signed`] message to be sent to or received from a peer.
|
| CommitmentTransaction |
This class tracks the per-transaction information needed to build a commitment transaction and will
actually build it and sign.
|
| CommitmentUpdate |
Struct used to return values from [`RevokeAndACK`] messages, containing a bunch of commitment
transaction updates if they were pending.
|
| Confirm |
The `Confirm` trait is used to notify LDK when relevant transactions have been confirmed on
chain or unconfirmed during a chain reorganization.
|
| Confirm.ConfirmInterface |
|
| ConfirmationTarget |
An enum that represents the speed at which we want a transaction to confirm used for feerate
estimation.
|
| COption_NoneZ |
An enum which can either contain a or not
|
| CounterpartyChannelTransactionParameters |
Late-bound per-channel counterparty data used to build transactions.
|
| CounterpartyCommitmentSecrets |
Implements the per-commitment secret storage scheme from
[BOLT 3](https://github.com/lightning/bolts/blob/dcbf8583976df087c79c3ce0b535311212e6812d/03-transactions.md#efficient-per-commitment-secret-storage).
|
| CounterpartyForwardingInfo |
Information needed for constructing an invoice route hint for this channel.
|
| CreationError |
Errors that may occur when constructing a new [`RawInvoice`] or [`Invoice`]
|
| Currency |
Enum representing the crypto currencies (or networks) supported by this library
|
| CustomMessageHandler |
A handler provided to [`PeerManager`] for reading and handling custom messages.
|
| CustomMessageHandler.CustomMessageHandlerInterface |
|
| CustomMessageReader |
Trait to be implemented by custom message (unrelated to the channel/gossip LN layers)
decoders.
|
| CustomMessageReader.CustomMessageReaderInterface |
|
| CustomOnionMessageContents |
The contents of a custom onion message.
|
| CustomOnionMessageContents.CustomOnionMessageContentsInterface |
|
| CustomOnionMessageHandler |
Handler for custom onion messages.
|
| CustomOnionMessageHandler.CustomOnionMessageHandlerInterface |
|
| DataLossProtect |
Proof that the sender knows the per-commitment secret of the previous commitment transaction.
|
| DecodeError |
An error in decoding a message or struct.
|
| DecodeError.BadLengthDescriptor |
A length descriptor in the packet didn't describe the later data correctly.
|
| DecodeError.InvalidValue |
Value was invalid.
|
| DecodeError.Io |
Error from [`std::io`].
|
| DecodeError.ShortRead |
The buffer to be read was too short.
|
| DecodeError.UnknownRequiredFeature |
Unknown feature mandating we fail to parse message (e.g., TLV with an even, unknown type)
|
| DecodeError.UnknownVersion |
A version byte specified something we don't know how to handle.
|
| DecodeError.UnsupportedCompression |
The message included zlib-compressed values, which we don't support.
|
| DefaultRouter |
A [`Router`] implemented using [`find_route`].
|
| DelayedPaymentOutputDescriptor |
Information about a spendable output to a P2WSH script.
|
| Description |
Description string
# Invariants
The description can be at most 639 __bytes__ long
|
| Destination |
The destination of an onion message.
|
| Destination.BlindedPath |
We're sending this onion message to a blinded path.
|
| Destination.Node |
We're sending this onion message to a node.
|
| DirectedChannelInfo |
A wrapper around [`ChannelInfo`] representing information about the channel as directed from a
source node to a target node.
|
| DirectedChannelTransactionParameters |
Static channel fields used to build transactions given per-commitment fields, organized by
broadcaster/countersignatory.
|
| EcdsaChannelSigner |
A trait to sign Lightning channel transactions as described in
[BOLT 3](https://github.com/lightning/bolts/blob/master/03-transactions.md).
|
| EcdsaChannelSigner.EcdsaChannelSignerInterface |
|
| EffectiveCapacity |
The effective capacity of a channel for routing purposes.
|
| EffectiveCapacity.ExactLiquidity |
The available liquidity in the channel known from being a channel counterparty, and thus a
direct hop.
|
| EffectiveCapacity.Infinite |
A capacity sufficient to route any payment, typically used for private channels provided by
an invoice.
|
| EffectiveCapacity.MaximumHTLC |
The maximum HTLC amount in one direction as advertised on the gossip network.
|
| EffectiveCapacity.Total |
The total capacity of the channel as determined by the funding transaction.
|
| EffectiveCapacity.Unknown |
A capacity that is unknown possibly because either the chain state is unavailable to know
the total capacity or the `htlc_maximum_msat` was not advertised on the gossip network.
|
| EntropySource |
A trait that describes a source of entropy.
|
| EntropySource.EntropySourceInterface |
|
| ErrorAction |
Used to put an error message in a [`LightningError`].
|
| ErrorAction.DisconnectPeer |
The peer took some action which made us think they were useless.
|
| ErrorAction.IgnoreAndLog |
The peer did something harmless that we weren't able to meaningfully process.
|
| ErrorAction.IgnoreDuplicateGossip |
The peer provided us with a gossip message which we'd already seen.
|
| ErrorAction.IgnoreError |
The peer did something harmless that we weren't able to process, just log and ignore
|
| ErrorAction.SendErrorMessage |
The peer did something incorrect.
|
| ErrorAction.SendWarningMessage |
The peer did something incorrect.
|
| ErroringMessageHandler |
A dummy struct which implements `ChannelMessageHandler` without having any channels.
|
| ErrorMessage |
An [`error`] message to be sent to or received from a peer.
|
| Event |
An Event which you should probably take some action in response to.
|
| Event.ChannelClosed |
Used to indicate that a previously opened channel with the given `channel_id` is in the
process of closure.
|
| Event.ChannelPending |
Used to indicate that a channel with the given `channel_id` is being opened and pending
confirmation on-chain.
|
| Event.ChannelReady |
Used to indicate that a channel with the given `channel_id` is ready to
be used.
|
| Event.DiscardFunding |
Used to indicate to the user that they can abandon the funding transaction and recycle the
inputs for another purpose.
|
| Event.FundingGenerationReady |
Used to indicate that the client should generate a funding transaction with the given
parameters and then call [`ChannelManager::funding_transaction_generated`].
|
| Event.HTLCHandlingFailed |
Indicates that the HTLC was accepted, but could not be processed when or after attempting to
forward it.
|
| Event.HTLCIntercepted |
Used to indicate that we've intercepted an HTLC forward.
|
| Event.OpenChannelRequest |
Indicates a request to open a new channel by a peer.
|
| Event.PaymentClaimable |
Indicates that we've been offered a payment and it needs to be claimed via calling
[`ChannelManager::claim_funds`] with the preimage given in [`PaymentPurpose`].
|
| Event.PaymentClaimed |
Indicates a payment has been claimed and we've received money!
This most likely occurs when [`ChannelManager::claim_funds`] has been called in response
to an [`Event::PaymentClaimable`].
|
| Event.PaymentFailed |
Indicates an outbound payment failed.
|
| Event.PaymentForwarded |
This event is generated when a payment has been successfully forwarded through us and a
forwarding fee earned.
|
| Event.PaymentPathFailed |
Indicates an outbound HTLC we sent failed, likely due to an intermediary node being unable to
handle the HTLC.
|
| Event.PaymentPathSuccessful |
Indicates that a path for an outbound payment was successful.
|
| Event.PaymentSent |
Indicates an outbound payment we made succeeded (i.e.
|
| Event.PendingHTLCsForwardable |
Used to indicate that [`ChannelManager::process_pending_htlc_forwards`] should be called at
a time in the future.
|
| Event.ProbeFailed |
Indicates that a probe payment we sent failed at an intermediary node on the path.
|
| Event.ProbeSuccessful |
Indicates that a probe payment we sent returned successful, i.e., only failed at the destination.
|
| Event.SpendableOutputs |
Used to indicate that an output which you should know how to spend was confirmed on chain
and is now spendable.
|
| EventHandler |
A trait implemented for objects handling events from [`EventsProvider`].
|
| EventHandler.EventHandlerInterface |
|
| EventsProvider |
A trait indicating an object may generate events.
|
| EventsProvider.EventsProviderInterface |
|
| ExpandedKey |
A set of keys that were HKDF-expanded from an initial call to
[`NodeSigner::get_inbound_payment_key_material`].
|
| ExpiryTime |
Positive duration that defines when (relatively to the timestamp) in the future the invoice
expires
|
| FailureCode |
This enum is used to specify which error data to send to peers when failing back an HTLC
using [`ChannelManager::fail_htlc_backwards_with_reason`].
|
| Fallback |
Fallback address in case no LN payment is possible
|
| Fallback.PubKeyHash |
|
| Fallback.ScriptHash |
|
| Fallback.SegWitProgram |
|
| FeeEstimator |
A trait which should be implemented to provide feerate information on a number of time
horizons.
|
| FeeEstimator.FeeEstimatorInterface |
|
| FilesystemPersister |
FilesystemPersister persists channel data on disk, where each channel's
data is stored in a file named after its funding outpoint.
|
| Filter |
The `Filter` trait defines behavior for indicating chain activity of interest pertaining to
channels.
|
| Filter.FilterInterface |
|
| FixedPenaltyScorer |
[`Score`] implementation that uses a fixed penalty.
|
| FundingCreated |
A [`funding_created`] message to be sent to or received from a peer.
|
| FundingSigned |
A [`funding_signed`] message to be sent to or received from a peer.
|
| Future |
A simple future which can complete once, and calls some callback(s) when it does so.
|
| FutureCallback |
A callback which is called when a [`Future`] completes.
|
| FutureCallback.FutureCallbackInterface |
|
| GossipSync |
Either [`P2PGossipSync`] or [`RapidGossipSync`].
|
| GossipSync.None |
No gossip sync.
|
| GossipSync.P2P |
Gossip sync via the lightning peer-to-peer network as defined by BOLT 7.
|
| GossipSync.Rapid |
Rapid gossip sync from a trusted server.
|
| GossipTimestampFilter |
A [`gossip_timestamp_filter`] message is used by a node to request
gossip relay for messages in the requested time range when the
`gossip_queries` feature has been negotiated.
|
| GraphSyncError |
All-encompassing standard error type that processing can return
|
| GraphSyncError.DecodeError |
Error trying to read the update data, typically due to an erroneous data length indication
that is greater than the actual amount of data provided
|
| GraphSyncError.LightningError |
Error applying the patch to the network graph, usually the result of updates that are too
old or missing prerequisite data to the application of updates out of order
|
| Hints |
Routing hints for the tail of the route.
|
| Hints.Blinded |
The recipient provided blinded paths and payinfo to reach them.
|
| Hints.Clear |
The recipient included these route hints in their BOLT11 invoice.
|
| HolderCommitmentTransaction |
Information needed to build and sign a holder's commitment transaction.
|
| Hostname |
Represents a hostname for serialization purposes.
|
| HTLCClaim |
Describes the type of HTLC claim as determined by analyzing the witness.
|
| HTLCDestination |
Intended destination of a failed HTLC as indicated in [`Event::HTLCHandlingFailed`].
|
| HTLCDestination.FailedPayment |
Failure scenario where an HTLC may have been forwarded to be intended for us,
but is invalid for some reason, so we reject it.
|
| HTLCDestination.InvalidForward |
We couldn't forward to the outgoing scid.
|
| HTLCDestination.NextHopChannel |
We tried forwarding to a channel but failed to do so.
|
| HTLCDestination.UnknownNextHop |
Scenario where we are unsure of the next node to forward the HTLC to.
|
| HTLCOutputInCommitment |
Information about an HTLC as it appears in a commitment transaction
|
| HTLCUpdate |
Simple structure sent back by `chain::Watch` when an HTLC from a forward channel is detected on
chain.
|
| IgnoringMessageHandler |
A dummy struct which implements `RoutingMessageHandler` without storing any routing information
or doing any processing.
|
| InFlightHtlcs |
A data structure for tracking in-flight HTLCs.
|
| Init |
An [`init`] message to be sent to or received from a peer.
|
| InitFeatures |
Features used within an `init` message.
|
| InMemorySigner |
A simple implementation of [`WriteableEcdsaChannelSigner`] that just keeps the private keys in memory.
|
| InternalUtils |
|
| InvalidShutdownScript |
An error occurring when converting from [`Script`] to [`ShutdownScript`].
|
| Invoice |
Represents a syntactically and semantically correct lightning BOLT11 invoice.
|
| InvoiceFeatures |
Features used within an invoice.
|
| InvoiceRequest |
An `InvoiceRequest` is a request for an [`Invoice`] formulated from an [`Offer`].
|
| InvoiceRequestFeatures |
Features used within an `invoice_request`.
|
| InvoiceSignature |
Recoverable signature
|
| IOError |
Represents an IO Error.
|
| KeysManager |
Simple implementation of [`EntropySource`], [`NodeSigner`], and [`SignerProvider`] that takes a
32-byte seed for use as a BIP 32 extended key and derives keys from that.
|
| Level |
An enum representing the available verbosity levels of the logger.
|
| LightningError |
An Err type for failure to process messages.
|
| Listen |
The `Listen` trait is used to notify when blocks have been connected or disconnected from the
chain.
|
| Listen.ListenInterface |
|
| LockableScore |
A scorer that is accessed under a lock.
|
| LockableScore.LockableScoreInterface |
|
| LockedChannelMonitor |
A read-only reference to a current ChannelMonitor.
|
| Logger |
A trait encapsulating the operations required of a logger
|
| Logger.LoggerInterface |
|
| MessageHandler |
Provides references to trait impls which handle different types of messages.
|
| MessageSendEvent |
An event generated by ChannelManager which indicates a message should be sent to a peer (or
broadcast to most peers).
|
| MessageSendEvent.BroadcastChannelAnnouncement |
Used to indicate that a channel_announcement and channel_update should be broadcast to all
peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
|
| MessageSendEvent.BroadcastChannelUpdate |
Used to indicate that a channel_update should be broadcast to all peers.
|
| MessageSendEvent.BroadcastNodeAnnouncement |
Used to indicate that a node_announcement should be broadcast to all peers.
|
| MessageSendEvent.HandleError |
Broadcast an error downstream to be handled
|
| MessageSendEvent.SendAcceptChannel |
Used to indicate that we've accepted a channel open and should send the accept_channel
message provided to the given peer.
|
| MessageSendEvent.SendAnnouncementSignatures |
Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendChannelAnnouncement |
Used to send a channel_announcement and channel_update to a specific peer, likely on
initial connection to ensure our peers know about our channels.
|
| MessageSendEvent.SendChannelRangeQuery |
Query a peer for channels with funding transaction UTXOs in a block range.
|
| MessageSendEvent.SendChannelReady |
Used to indicate that a channel_ready message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendChannelReestablish |
Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendChannelUpdate |
Used to indicate that a channel_update should be sent to a single peer.
|
| MessageSendEvent.SendClosingSigned |
Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendFundingCreated |
Used to indicate that a funding_created message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendFundingSigned |
Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendGossipTimestampFilter |
Sends a timestamp filter for inbound gossip.
|
| MessageSendEvent.SendOpenChannel |
Used to indicate that we've initiated a channel open and should send the open_channel
message provided to the given peer.
|
| MessageSendEvent.SendReplyChannelRange |
Sends a reply to a channel range query.
|
| MessageSendEvent.SendRevokeAndACK |
Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
|
| MessageSendEvent.SendShortIdsQuery |
Request routing gossip messages from a peer for a list of channels identified by
their short_channel_ids.
|
| MessageSendEvent.SendShutdown |
Used to indicate that a shutdown message should be sent to the peer with the given node_id.
|
| MessageSendEvent.UpdateHTLCs |
Used to indicate that a series of HTLC update messages, as well as a commitment_signed
message should be sent to the peer with the given node_id.
|
| MessageSendEventsProvider |
A trait indicating an object may generate message send events
|
| MessageSendEventsProvider.MessageSendEventsProviderInterface |
|
| MinFinalCltvExpiryDelta |
`min_final_cltv_expiry_delta` to use for the last HTLC in the route
|
| MonitorEvent |
An event to be processed by the ChannelManager.
|
| MonitorEvent.CommitmentTxConfirmed |
A monitor event that the Channel's commitment transaction was confirmed.
|
| MonitorEvent.Completed |
Indicates a [`ChannelMonitor`] update has completed.
|
| MonitorEvent.HTLCEvent |
A monitor event containing an HTLCUpdate.
|
| MonitorEvent.UpdateFailed |
Indicates a [`ChannelMonitor`] update has failed.
|
| MonitorUpdateId |
An opaque identifier describing a specific [`Persist`] method call.
|
| MultiThreadedLockableScore |
A concrete implementation of [`LockableScore`] which supports multi-threading.
|
| MultiThreadedScoreLock |
A locked `MultiThreadedLockableScore`.
|
| NetAddress |
An address which can be used to connect to a remote peer.
|
| NetAddress.Hostname |
A hostname/port on which the peer is listening.
|
| NetAddress.IPv4 |
An IPv4 address/port on which the peer is listening.
|
| NetAddress.IPv6 |
An IPv6 address/port on which the peer is listening.
|
| NetAddress.OnionV2 |
An old-style Tor onion address/port on which the peer is listening.
|
| NetAddress.OnionV3 |
A new-style Tor onion address/port on which the peer is listening.
|
| Network |
An enum representing the possible Bitcoin or test networks which we can run on
|
| NetworkGraph |
Represents the network as nodes and channels between them
|
| NetworkUpdate |
Update to the [`NetworkGraph`] based on payment failure information conveyed via the Onion
return packet by a node along the route.
|
| NetworkUpdate.ChannelFailure |
An error indicating that a channel failed to route a payment, which should be applied via
[`NetworkGraph::channel_failed_permanent`] if permanent.
|
| NetworkUpdate.ChannelUpdateMessage |
An error indicating a `channel_update` messages should be applied via
[`NetworkGraph::update_channel`].
|
| NetworkUpdate.NodeFailure |
An error indicating that a node failed to route a payment, which should be applied via
[`NetworkGraph::node_failed_permanent`] if permanent.
|
| NioPeerHandler |
A NioPeerHandler maps LDK's PeerHandler to Java's NIO I/O interface.
|
| NodeAlias |
A user-defined name for a node, which may be used when displaying the node in a graph.
|
| NodeAnnouncement |
A [`node_announcement`] message to be sent to or received from a peer.
|
| NodeAnnouncementInfo |
Information received in the latest node_announcement from this node.
|
| NodeFeatures |
Features used within a `node_announcement` message.
|
| NodeId |
Represents the compressed public key of a node
|
| NodeInfo |
Details about a node in the network, known from the network announcement.
|
| NodeSigner |
A trait that can handle cryptographic operations at the scope level of a node.
|
| NodeSigner.NodeSignerInterface |
|
| Offer |
An `Offer` is a potentially long-lived proposal for payment of a good or service.
|
| OfferFeatures |
Features used within an `offer`.
|
| OnionMessage |
An onion message to be sent to or received from a peer.
|
| OnionMessageContents |
The contents of an onion message.
|
| OnionMessageContents.Custom |
A custom onion message specified by the user.
|
| OnionMessageHandler |
A trait to describe an object that can receive onion messages.
|
| OnionMessageHandler.OnionMessageHandlerInterface |
|
| OnionMessageProvider |
A trait indicating an object may generate onion messages to send
|
| OnionMessageProvider.OnionMessageProviderInterface |
|
| OnionMessenger |
A sender, receiver and forwarder of onion messages.
|
| OpenChannel |
An [`open_channel`] message to be sent to or received from a peer.
|
| Option_APIErrorZ |
An enum which can either contain a crate::lightning::util::errors::APIError or not
|
| Option_APIErrorZ.None |
When we're in this state, this COption_APIErrorZ contains nothing
|
| Option_APIErrorZ.Some |
When we're in this state, this COption_APIErrorZ contains a crate::lightning::util::errors::APIError
|
| Option_C2Tuple_EightU16sEightU16sZZ |
An enum which can either contain a crate::c_types::derived::C2Tuple__u168_u168Z or not
|
| Option_C2Tuple_EightU16sEightU16sZZ.None |
When we're in this state, this COption_C2Tuple_EightU16sEightU16sZZ contains nothing
|
| Option_C2Tuple_EightU16sEightU16sZZ.Some |
When we're in this state, this COption_C2Tuple_EightU16sEightU16sZZ contains a crate::c_types::derived::C2Tuple__u168_u168Z
|
| Option_C2Tuple_u64u64ZZ |
An enum which can either contain a crate::c_types::derived::C2Tuple_u64u64Z or not
|
| Option_C2Tuple_u64u64ZZ.None |
When we're in this state, this COption_C2Tuple_u64u64ZZ contains nothing
|
| Option_C2Tuple_u64u64ZZ.Some |
When we're in this state, this COption_C2Tuple_u64u64ZZ contains a crate::c_types::derived::C2Tuple_u64u64Z
|
| Option_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ |
An enum which can either contain a crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ or not
|
| Option_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ.None |
When we're in this state, this COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ contains nothing
|
| Option_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ.Some |
When we're in this state, this COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ contains a crate::c_types::derived::C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ
|
| Option_ClosureReasonZ |
An enum which can either contain a crate::lightning::events::ClosureReason or not
|
| Option_ClosureReasonZ.None |
When we're in this state, this COption_ClosureReasonZ contains nothing
|
| Option_ClosureReasonZ.Some |
When we're in this state, this COption_ClosureReasonZ contains a crate::lightning::events::ClosureReason
|
| Option_CustomOnionMessageContentsZ |
An enum which can either contain a crate::lightning::onion_message::packet::CustomOnionMessageContents or not
|
| Option_CustomOnionMessageContentsZ.None |
When we're in this state, this COption_CustomOnionMessageContentsZ contains nothing
|
| Option_CustomOnionMessageContentsZ.Some |
When we're in this state, this COption_CustomOnionMessageContentsZ contains a crate::lightning::onion_message::packet::CustomOnionMessageContents
|
| Option_CVec_NetAddressZZ |
An enum which can either contain a crate::c_types::derived::CVec_NetAddressZ or not
|
| Option_CVec_NetAddressZZ.None |
When we're in this state, this COption_CVec_NetAddressZZ contains nothing
|
| Option_CVec_NetAddressZZ.Some |
When we're in this state, this COption_CVec_NetAddressZZ contains a crate::c_types::derived::CVec_NetAddressZ
|
| Option_CVec_u8ZZ |
An enum which can either contain a crate::c_types::derived::CVec_u8Z or not
|
| Option_CVec_u8ZZ.None |
When we're in this state, this COption_CVec_u8ZZ contains nothing
|
| Option_CVec_u8ZZ.Some |
When we're in this state, this COption_CVec_u8ZZ contains a crate::c_types::derived::CVec_u8Z
|
| Option_DurationZ |
An enum which can either contain a u64 or not
|
| Option_DurationZ.None |
When we're in this state, this COption_DurationZ contains nothing
|
| Option_DurationZ.Some |
When we're in this state, this COption_DurationZ contains a u64
|
| Option_EventZ |
An enum which can either contain a crate::lightning::events::Event or not
|
| Option_EventZ.None |
When we're in this state, this COption_EventZ contains nothing
|
| Option_EventZ.Some |
When we're in this state, this COption_EventZ contains a crate::lightning::events::Event
|
| Option_FilterZ |
An enum which can either contain a crate::lightning::chain::Filter or not
|
| Option_FilterZ.None |
When we're in this state, this COption_FilterZ contains nothing
|
| Option_FilterZ.Some |
When we're in this state, this COption_FilterZ contains a crate::lightning::chain::Filter
|
| Option_HTLCClaimZ |
An enum which can either contain a crate::lightning::ln::chan_utils::HTLCClaim or not
|
| Option_HTLCClaimZ.None |
When we're in this state, this COption_HTLCClaimZ contains nothing
|
| Option_HTLCClaimZ.Some |
When we're in this state, this COption_HTLCClaimZ contains a crate::lightning::ln::chan_utils::HTLCClaim
|
| Option_HTLCDestinationZ |
An enum which can either contain a crate::lightning::events::HTLCDestination or not
|
| Option_HTLCDestinationZ.None |
When we're in this state, this COption_HTLCDestinationZ contains nothing
|
| Option_HTLCDestinationZ.Some |
When we're in this state, this COption_HTLCDestinationZ contains a crate::lightning::events::HTLCDestination
|
| Option_MonitorEventZ |
An enum which can either contain a crate::lightning::chain::channelmonitor::MonitorEvent or not
|
| Option_MonitorEventZ.None |
When we're in this state, this COption_MonitorEventZ contains nothing
|
| Option_MonitorEventZ.Some |
When we're in this state, this COption_MonitorEventZ contains a crate::lightning::chain::channelmonitor::MonitorEvent
|
| Option_NetAddressZ |
An enum which can either contain a crate::lightning::ln::msgs::NetAddress or not
|
| Option_NetAddressZ.None |
When we're in this state, this COption_NetAddressZ contains nothing
|
| Option_NetAddressZ.Some |
When we're in this state, this COption_NetAddressZ contains a crate::lightning::ln::msgs::NetAddress
|
| Option_NetworkUpdateZ |
An enum which can either contain a crate::lightning::routing::gossip::NetworkUpdate or not
|
| Option_NetworkUpdateZ.None |
When we're in this state, this COption_NetworkUpdateZ contains nothing
|
| Option_NetworkUpdateZ.Some |
When we're in this state, this COption_NetworkUpdateZ contains a crate::lightning::routing::gossip::NetworkUpdate
|
| Option_PathFailureZ |
An enum which can either contain a crate::lightning::events::PathFailure or not
|
| Option_PathFailureZ.None |
When we're in this state, this COption_PathFailureZ contains nothing
|
| Option_PathFailureZ.Some |
When we're in this state, this COption_PathFailureZ contains a crate::lightning::events::PathFailure
|
| Option_PaymentFailureReasonZ |
An enum which can either contain a crate::lightning::events::PaymentFailureReason or not
|
| Option_PaymentFailureReasonZ.None |
When we're in this state, this COption_PaymentFailureReasonZ contains nothing
|
| Option_PaymentFailureReasonZ.Some |
When we're in this state, this COption_PaymentFailureReasonZ contains a crate::lightning::events::PaymentFailureReason
|
| Option_ScalarZ |
An enum which can either contain a crate::c_types::BigEndianScalar or not
|
| Option_ScalarZ.None |
When we're in this state, this COption_ScalarZ contains nothing
|
| Option_ScalarZ.Some |
When we're in this state, this COption_ScalarZ contains a crate::c_types::BigEndianScalar
|
| Option_TypeZ |
An enum which can either contain a crate::lightning::ln::wire::Type or not
|
| Option_TypeZ.None |
When we're in this state, this COption_TypeZ contains nothing
|
| Option_TypeZ.Some |
When we're in this state, this COption_TypeZ contains a crate::lightning::ln::wire::Type
|
| Option_u128Z |
An enum which can either contain a crate::c_types::U128 or not
|
| Option_u128Z.None |
When we're in this state, this COption_u128Z contains nothing
|
| Option_u128Z.Some |
When we're in this state, this COption_u128Z contains a crate::c_types::U128
|
| Option_u16Z |
An enum which can either contain a u16 or not
|
| Option_u16Z.None |
When we're in this state, this COption_u16Z contains nothing
|
| Option_u16Z.Some |
When we're in this state, this COption_u16Z contains a u16
|
| Option_u32Z |
An enum which can either contain a u32 or not
|
| Option_u32Z.None |
When we're in this state, this COption_u32Z contains nothing
|
| Option_u32Z.Some |
When we're in this state, this COption_u32Z contains a u32
|
| Option_u64Z |
An enum which can either contain a u64 or not
|
| Option_u64Z.None |
When we're in this state, this COption_u64Z contains nothing
|
| Option_u64Z.Some |
When we're in this state, this COption_u64Z contains a u64
|
| Option_UtxoLookupZ |
An enum which can either contain a crate::lightning::routing::utxo::UtxoLookup or not
|
| Option_UtxoLookupZ.None |
When we're in this state, this COption_UtxoLookupZ contains nothing
|
| Option_UtxoLookupZ.Some |
When we're in this state, this COption_UtxoLookupZ contains a crate::lightning::routing::utxo::UtxoLookup
|
| Option_WriteableScoreZ |
An enum which can either contain a crate::lightning::routing::scoring::WriteableScore or not
|
| Option_WriteableScoreZ.None |
When we're in this state, this COption_WriteableScoreZ contains nothing
|
| Option_WriteableScoreZ.Some |
When we're in this state, this COption_WriteableScoreZ contains a crate::lightning::routing::scoring::WriteableScore
|
| OutPoint |
A reference to a transaction output.
|
| P2PGossipSync |
Receives and validates network updates from peers,
stores authentic and relevant data as a network graph.
|
| ParseError |
Errors that indicate what is wrong with the invoice.
|
| ParseError.BadPrefix |
|
| ParseError.Bech32Error |
|
| ParseError.DescriptionDecodeError |
|
| ParseError.IntegerOverflowError |
|
| ParseError.InvalidPubKeyHashLength |
|
| ParseError.InvalidRecoveryId |
|
| ParseError.InvalidScriptHashLength |
|
| ParseError.InvalidSegWitProgramLength |
|
| ParseError.InvalidSliceLength |
|
| ParseError.MalformedHRP |
|
| ParseError.MalformedSignature |
|
| ParseError.PaddingError |
|
| ParseError.ParseAmountError |
|
| ParseError.Skip |
Not an error, but used internally to signal that a part of the invoice should be ignored
according to BOLT11
|
| ParseError.TooShortDataPart |
|
| ParseError.UnexpectedEndOfTaggedFields |
|
| ParseError.UnknownCurrency |
|
| ParseError.UnknownSiPrefix |
|
| ParseOrSemanticError |
Indicates that something went wrong while parsing or validating the invoice.
|
| ParseOrSemanticError.ParseError |
The invoice couldn't be decoded
|
| ParseOrSemanticError.SemanticError |
The invoice could be decoded but violates the BOLT11 standard
|
| Path |
A path in a [`Route`] to the payment recipient.
|
| PathFailure |
When the payment path failure took place and extra details about it.
|
| PathFailure.InitialSend |
We failed to initially send the payment and no HTLC was committed to.
|
| PathFailure.OnPath |
A hop on the path failed to forward our payment.
|
| PayeePubKey |
Payee public key
|
| PaymentError |
An error that may occur when making a payment.
|
| PaymentError.Invoice |
An error resulting from the provided [`Invoice`] or payment hash.
|
| PaymentError.Sending |
An error occurring when sending a payment.
|
| PaymentFailureReason |
The reason the payment failed.
|
| PaymentParameters |
The recipient of a payment.
|
| PaymentPurpose |
Some information provided on receipt of payment depends on whether the payment received is a
spontaneous payment or a \"conventional\" lightning payment that's paying an invoice.
|
| PaymentPurpose.InvoicePayment |
Information for receiving a payment that we generated an invoice for.
|
| PaymentPurpose.SpontaneousPayment |
Because this is a spontaneous payment, the payer generated their own preimage rather than us
(the payee) providing a preimage.
|
| PaymentSendFailure |
If a payment fails to send with [`ChannelManager::send_payment_with_route`], it can be in one
of several states.
|
| PaymentSendFailure.AllFailedResendSafe |
All paths which were attempted failed to send, with no channel state change taking place.
|
| PaymentSendFailure.DuplicatePayment |
Indicates that a payment for the provided [`PaymentId`] is already in-flight and has not
yet completed (i.e.
|
| PaymentSendFailure.ParameterError |
A parameter which was passed to send_payment was invalid, preventing us from attempting to
send the payment at all.
|
| PaymentSendFailure.PartialFailure |
Some paths that were attempted failed to send, though some paths may have succeeded.
|
| PaymentSendFailure.PathParameterError |
A parameter in a single path which was passed to send_payment was invalid, preventing us
from attempting to send the payment at all.
|
| PeerHandleError |
Error for PeerManager errors.
|
| PeerManager |
A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls
socket events into messages which it passes on to its [`MessageHandler`].
|
| Persist |
`Persist` defines behavior for persisting channel monitors: this could mean
writing once to disk, and/or uploading to one or more backup services.
|
| Persist.PersistInterface |
|
| Persister |
Trait that handles persisting a [`ChannelManager`], [`NetworkGraph`], and [`WriteableScore`] to disk.
|
| Persister.PersisterInterface |
|
| PhantomKeysManager |
Similar to [`KeysManager`], but allows the node using this struct to receive phantom node
payments.
|
| PhantomRouteHints |
Route hints used in constructing invoices for [phantom node payents].
|
| Ping |
A [`ping`] message to be sent to or received from a peer.
|
| Pong |
A [`pong`] message to be sent to or received from a peer.
|
| PositiveTimestamp |
A timestamp that refers to a date after 1 January 1970.
|
| PrintableString |
A string that displays only printable characters, replacing control characters with
[`core::char::REPLACEMENT_CHARACTER`].
|
| PrivateRoute |
Private routing information
# Invariants
The encoded route has to be <1024 5bit characters long (<=639 bytes or <=12 hops)
|
| ProbabilisticScorer |
[`Score`] implementation using channel success probability distributions.
|
| ProbabilisticScoringParameters |
Parameters for configuring [`ProbabilisticScorer`].
|
| Quantity |
Quantity of items supported by an [`Offer`].
|
| QueryChannelRange |
A [`query_channel_range`] message is used to query a peer for channel
UTXOs in a range of blocks.
|
| QueryShortChannelIds |
A [`query_short_channel_ids`] message is used to query a peer for
routing gossip messages related to one or more `short_channel_id`s.
|
| RapidGossipSync |
The main Rapid Gossip Sync object.
|
| RawDataPart |
Data of the [`RawInvoice`] that is encoded in the data part
|
| RawInvoice |
Represents an syntactically correct [`Invoice`] for a payment on the lightning network,
but without the signature information.
|
| ReadOnlyNetworkGraph |
A read-only view of [`NetworkGraph`].
|
| RecentPaymentDetails |
Used by [`ChannelManager::list_recent_payments`] to express the status of recent payments.
|
| RecentPaymentDetails.Abandoned |
After a payment's retries are exhausted per the provided [`Retry`], or it is explicitly
abandoned via [`ChannelManager::abandon_payment`], it is marked as abandoned until all
pending HTLCs for this payment resolve and an [`Event::PaymentFailed`] is generated.
|
| RecentPaymentDetails.Fulfilled |
When a pending payment is fulfilled, we continue tracking it until all pending HTLCs have
been resolved.
|
| RecentPaymentDetails.Pending |
When a payment is still being sent and awaiting successful delivery.
|
| Recipient |
Specifies the recipient of an invoice.
|
| RecipientOnionFields |
Information which is provided, encrypted, to the payment recipient when sending HTLCs.
|
| Record |
A Record, unit of logging output with Metadata to enable filtering
Module_path, file, line to inform on log's source
|
| Refund |
A `Refund` is a request to send an [`Invoice`] without a preceding [`Offer`].
|
| ReplyChannelRange |
A [`reply_channel_range`] message is a reply to a [`QueryChannelRange`]
message.
|
| ReplyShortChannelIdsEnd |
A [`reply_short_channel_ids_end`] message is sent as a reply to a
message.
|
| Result__u832APIErrorZ |
|
| Result__u832APIErrorZ.Result__u832APIErrorZ_Err |
|
| Result__u832APIErrorZ.Result__u832APIErrorZ_OK |
|
| Result_AcceptChannelDecodeErrorZ |
|
| Result_AcceptChannelDecodeErrorZ.Result_AcceptChannelDecodeErrorZ_Err |
|
| Result_AcceptChannelDecodeErrorZ.Result_AcceptChannelDecodeErrorZ_OK |
|
| Result_AnnouncementSignaturesDecodeErrorZ |
|
| Result_AnnouncementSignaturesDecodeErrorZ.Result_AnnouncementSignaturesDecodeErrorZ_Err |
|
| Result_AnnouncementSignaturesDecodeErrorZ.Result_AnnouncementSignaturesDecodeErrorZ_OK |
|
| Result_BlindedHopDecodeErrorZ |
|
| Result_BlindedHopDecodeErrorZ.Result_BlindedHopDecodeErrorZ_Err |
|
| Result_BlindedHopDecodeErrorZ.Result_BlindedHopDecodeErrorZ_OK |
|
| Result_BlindedHopFeaturesDecodeErrorZ |
|
| Result_BlindedHopFeaturesDecodeErrorZ.Result_BlindedHopFeaturesDecodeErrorZ_Err |
|
| Result_BlindedHopFeaturesDecodeErrorZ.Result_BlindedHopFeaturesDecodeErrorZ_OK |
|
| Result_BlindedPathDecodeErrorZ |
|
| Result_BlindedPathDecodeErrorZ.Result_BlindedPathDecodeErrorZ_Err |
|
| Result_BlindedPathDecodeErrorZ.Result_BlindedPathDecodeErrorZ_OK |
|
| Result_BlindedPathNoneZ |
|
| Result_BlindedPathNoneZ.Result_BlindedPathNoneZ_Err |
|
| Result_BlindedPathNoneZ.Result_BlindedPathNoneZ_OK |
|
| Result_BlindedPayInfoDecodeErrorZ |
|
| Result_BlindedPayInfoDecodeErrorZ.Result_BlindedPayInfoDecodeErrorZ_Err |
|
| Result_BlindedPayInfoDecodeErrorZ.Result_BlindedPayInfoDecodeErrorZ_OK |
|
| Result_BlindedTailDecodeErrorZ |
|
| Result_BlindedTailDecodeErrorZ.Result_BlindedTailDecodeErrorZ_Err |
|
| Result_BlindedTailDecodeErrorZ.Result_BlindedTailDecodeErrorZ_OK |
|
| Result_boolLightningErrorZ |
|
| Result_boolLightningErrorZ.Result_boolLightningErrorZ_Err |
|
| Result_boolLightningErrorZ.Result_boolLightningErrorZ_OK |
|
| Result_boolPeerHandleErrorZ |
|
| Result_boolPeerHandleErrorZ.Result_boolPeerHandleErrorZ_Err |
|
| Result_boolPeerHandleErrorZ.Result_boolPeerHandleErrorZ_OK |
|
| Result_BuiltCommitmentTransactionDecodeErrorZ |
|
| Result_BuiltCommitmentTransactionDecodeErrorZ.Result_BuiltCommitmentTransactionDecodeErrorZ_Err |
|
| Result_BuiltCommitmentTransactionDecodeErrorZ.Result_BuiltCommitmentTransactionDecodeErrorZ_OK |
|
| Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ |
|
| Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_Err |
|
| Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ.Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_OK |
|
| Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ |
|
| Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_Err |
|
| Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK |
|
| Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ |
|
| Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ.Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_Err |
|
| Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ.Result_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_OK |
|
| Result_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ |
|
| Result_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ.Result_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_Err |
|
| Result_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ.Result_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_OK |
|
| Result_C2Tuple_PaymentHashPaymentSecretZNoneZ |
|
| Result_C2Tuple_PaymentHashPaymentSecretZNoneZ.Result_C2Tuple_PaymentHashPaymentSecretZNoneZ_Err |
|
| Result_C2Tuple_PaymentHashPaymentSecretZNoneZ.Result_C2Tuple_PaymentHashPaymentSecretZNoneZ_OK |
|
| Result_C2Tuple_SignatureCVec_SignatureZZNoneZ |
|
| Result_C2Tuple_SignatureCVec_SignatureZZNoneZ.Result_C2Tuple_SignatureCVec_SignatureZZNoneZ_Err |
|
| Result_C2Tuple_SignatureCVec_SignatureZZNoneZ.Result_C2Tuple_SignatureCVec_SignatureZZNoneZ_OK |
|
| Result_ChannelAnnouncementDecodeErrorZ |
|
| Result_ChannelAnnouncementDecodeErrorZ.Result_ChannelAnnouncementDecodeErrorZ_Err |
|
| Result_ChannelAnnouncementDecodeErrorZ.Result_ChannelAnnouncementDecodeErrorZ_OK |
|
| Result_ChannelConfigDecodeErrorZ |
|
| Result_ChannelConfigDecodeErrorZ.Result_ChannelConfigDecodeErrorZ_Err |
|
| Result_ChannelConfigDecodeErrorZ.Result_ChannelConfigDecodeErrorZ_OK |
|
| Result_ChannelCounterpartyDecodeErrorZ |
|
| Result_ChannelCounterpartyDecodeErrorZ.Result_ChannelCounterpartyDecodeErrorZ_Err |
|
| Result_ChannelCounterpartyDecodeErrorZ.Result_ChannelCounterpartyDecodeErrorZ_OK |
|
| Result_ChannelDetailsDecodeErrorZ |
|
| Result_ChannelDetailsDecodeErrorZ.Result_ChannelDetailsDecodeErrorZ_Err |
|
| Result_ChannelDetailsDecodeErrorZ.Result_ChannelDetailsDecodeErrorZ_OK |
|
| Result_ChannelFeaturesDecodeErrorZ |
|
| Result_ChannelFeaturesDecodeErrorZ.Result_ChannelFeaturesDecodeErrorZ_Err |
|
| Result_ChannelFeaturesDecodeErrorZ.Result_ChannelFeaturesDecodeErrorZ_OK |
|
| Result_ChannelInfoDecodeErrorZ |
|
| Result_ChannelInfoDecodeErrorZ.Result_ChannelInfoDecodeErrorZ_Err |
|
| Result_ChannelInfoDecodeErrorZ.Result_ChannelInfoDecodeErrorZ_OK |
|
| Result_ChannelMonitorUpdateDecodeErrorZ |
|
| Result_ChannelMonitorUpdateDecodeErrorZ.Result_ChannelMonitorUpdateDecodeErrorZ_Err |
|
| Result_ChannelMonitorUpdateDecodeErrorZ.Result_ChannelMonitorUpdateDecodeErrorZ_OK |
|
| Result_ChannelPublicKeysDecodeErrorZ |
|
| Result_ChannelPublicKeysDecodeErrorZ.Result_ChannelPublicKeysDecodeErrorZ_Err |
|
| Result_ChannelPublicKeysDecodeErrorZ.Result_ChannelPublicKeysDecodeErrorZ_OK |
|
| Result_ChannelReadyDecodeErrorZ |
|
| Result_ChannelReadyDecodeErrorZ.Result_ChannelReadyDecodeErrorZ_Err |
|
| Result_ChannelReadyDecodeErrorZ.Result_ChannelReadyDecodeErrorZ_OK |
|
| Result_ChannelReestablishDecodeErrorZ |
|
| Result_ChannelReestablishDecodeErrorZ.Result_ChannelReestablishDecodeErrorZ_Err |
|
| Result_ChannelReestablishDecodeErrorZ.Result_ChannelReestablishDecodeErrorZ_OK |
|
| Result_ChannelTransactionParametersDecodeErrorZ |
|
| Result_ChannelTransactionParametersDecodeErrorZ.Result_ChannelTransactionParametersDecodeErrorZ_Err |
|
| Result_ChannelTransactionParametersDecodeErrorZ.Result_ChannelTransactionParametersDecodeErrorZ_OK |
|
| Result_ChannelTypeFeaturesDecodeErrorZ |
|
| Result_ChannelTypeFeaturesDecodeErrorZ.Result_ChannelTypeFeaturesDecodeErrorZ_Err |
|
| Result_ChannelTypeFeaturesDecodeErrorZ.Result_ChannelTypeFeaturesDecodeErrorZ_OK |
|
| Result_ChannelUpdateDecodeErrorZ |
|
| Result_ChannelUpdateDecodeErrorZ.Result_ChannelUpdateDecodeErrorZ_Err |
|
| Result_ChannelUpdateDecodeErrorZ.Result_ChannelUpdateDecodeErrorZ_OK |
|
| Result_ChannelUpdateInfoDecodeErrorZ |
|
| Result_ChannelUpdateInfoDecodeErrorZ.Result_ChannelUpdateInfoDecodeErrorZ_Err |
|
| Result_ChannelUpdateInfoDecodeErrorZ.Result_ChannelUpdateInfoDecodeErrorZ_OK |
|
| Result_ClosingSignedDecodeErrorZ |
|
| Result_ClosingSignedDecodeErrorZ.Result_ClosingSignedDecodeErrorZ_Err |
|
| Result_ClosingSignedDecodeErrorZ.Result_ClosingSignedDecodeErrorZ_OK |
|
| Result_ClosingSignedFeeRangeDecodeErrorZ |
|
| Result_ClosingSignedFeeRangeDecodeErrorZ.Result_ClosingSignedFeeRangeDecodeErrorZ_Err |
|
| Result_ClosingSignedFeeRangeDecodeErrorZ.Result_ClosingSignedFeeRangeDecodeErrorZ_OK |
|
| Result_CommitmentSignedDecodeErrorZ |
|
| Result_CommitmentSignedDecodeErrorZ.Result_CommitmentSignedDecodeErrorZ_Err |
|
| Result_CommitmentSignedDecodeErrorZ.Result_CommitmentSignedDecodeErrorZ_OK |
|
| Result_CommitmentTransactionDecodeErrorZ |
|
| Result_CommitmentTransactionDecodeErrorZ.Result_CommitmentTransactionDecodeErrorZ_Err |
|
| Result_CommitmentTransactionDecodeErrorZ.Result_CommitmentTransactionDecodeErrorZ_OK |
|
| Result_COption_APIErrorZDecodeErrorZ |
|
| Result_COption_APIErrorZDecodeErrorZ.Result_COption_APIErrorZDecodeErrorZ_Err |
|
| Result_COption_APIErrorZDecodeErrorZ.Result_COption_APIErrorZDecodeErrorZ_OK |
|
| Result_COption_ClosureReasonZDecodeErrorZ |
|
| Result_COption_ClosureReasonZDecodeErrorZ.Result_COption_ClosureReasonZDecodeErrorZ_Err |
|
| Result_COption_ClosureReasonZDecodeErrorZ.Result_COption_ClosureReasonZDecodeErrorZ_OK |
|
| Result_COption_CustomOnionMessageContentsZDecodeErrorZ |
|
| Result_COption_CustomOnionMessageContentsZDecodeErrorZ.Result_COption_CustomOnionMessageContentsZDecodeErrorZ_Err |
|
| Result_COption_CustomOnionMessageContentsZDecodeErrorZ.Result_COption_CustomOnionMessageContentsZDecodeErrorZ_OK |
|
| Result_COption_EventZDecodeErrorZ |
|
| Result_COption_EventZDecodeErrorZ.Result_COption_EventZDecodeErrorZ_Err |
|
| Result_COption_EventZDecodeErrorZ.Result_COption_EventZDecodeErrorZ_OK |
|
| Result_COption_HTLCDestinationZDecodeErrorZ |
|
| Result_COption_HTLCDestinationZDecodeErrorZ.Result_COption_HTLCDestinationZDecodeErrorZ_Err |
|
| Result_COption_HTLCDestinationZDecodeErrorZ.Result_COption_HTLCDestinationZDecodeErrorZ_OK |
|
| Result_COption_MonitorEventZDecodeErrorZ |
|
| Result_COption_MonitorEventZDecodeErrorZ.Result_COption_MonitorEventZDecodeErrorZ_Err |
|
| Result_COption_MonitorEventZDecodeErrorZ.Result_COption_MonitorEventZDecodeErrorZ_OK |
|
| Result_COption_NetworkUpdateZDecodeErrorZ |
|
| Result_COption_NetworkUpdateZDecodeErrorZ.Result_COption_NetworkUpdateZDecodeErrorZ_Err |
|
| Result_COption_NetworkUpdateZDecodeErrorZ.Result_COption_NetworkUpdateZDecodeErrorZ_OK |
|
| Result_COption_PathFailureZDecodeErrorZ |
|
| Result_COption_PathFailureZDecodeErrorZ.Result_COption_PathFailureZDecodeErrorZ_Err |
|
| Result_COption_PathFailureZDecodeErrorZ.Result_COption_PathFailureZDecodeErrorZ_OK |
|
| Result_COption_TypeZDecodeErrorZ |
|
| Result_COption_TypeZDecodeErrorZ.Result_COption_TypeZDecodeErrorZ_Err |
|
| Result_COption_TypeZDecodeErrorZ.Result_COption_TypeZDecodeErrorZ_OK |
|
| Result_CounterpartyChannelTransactionParametersDecodeErrorZ |
|
| Result_CounterpartyChannelTransactionParametersDecodeErrorZ.Result_CounterpartyChannelTransactionParametersDecodeErrorZ_Err |
|
| Result_CounterpartyChannelTransactionParametersDecodeErrorZ.Result_CounterpartyChannelTransactionParametersDecodeErrorZ_OK |
|
| Result_CounterpartyCommitmentSecretsDecodeErrorZ |
|
| Result_CounterpartyCommitmentSecretsDecodeErrorZ.Result_CounterpartyCommitmentSecretsDecodeErrorZ_Err |
|
| Result_CounterpartyCommitmentSecretsDecodeErrorZ.Result_CounterpartyCommitmentSecretsDecodeErrorZ_OK |
|
| Result_CounterpartyForwardingInfoDecodeErrorZ |
|
| Result_CounterpartyForwardingInfoDecodeErrorZ.Result_CounterpartyForwardingInfoDecodeErrorZ_Err |
|
| Result_CounterpartyForwardingInfoDecodeErrorZ.Result_CounterpartyForwardingInfoDecodeErrorZ_OK |
|
| Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ |
|
| Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_Err |
|
| Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ.Result_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_OK |
|
| Result_CVec_CVec_u8ZZNoneZ |
|
| Result_CVec_CVec_u8ZZNoneZ.Result_CVec_CVec_u8ZZNoneZ_Err |
|
| Result_CVec_CVec_u8ZZNoneZ.Result_CVec_CVec_u8ZZNoneZ_OK |
|
| Result_CVec_SignatureZNoneZ |
|
| Result_CVec_SignatureZNoneZ.Result_CVec_SignatureZNoneZ_Err |
|
| Result_CVec_SignatureZNoneZ.Result_CVec_SignatureZNoneZ_OK |
|
| Result_CVec_u8ZPeerHandleErrorZ |
|
| Result_CVec_u8ZPeerHandleErrorZ.Result_CVec_u8ZPeerHandleErrorZ_Err |
|
| Result_CVec_u8ZPeerHandleErrorZ.Result_CVec_u8ZPeerHandleErrorZ_OK |
|
| Result_DelayedPaymentOutputDescriptorDecodeErrorZ |
|
| Result_DelayedPaymentOutputDescriptorDecodeErrorZ.Result_DelayedPaymentOutputDescriptorDecodeErrorZ_Err |
|
| Result_DelayedPaymentOutputDescriptorDecodeErrorZ.Result_DelayedPaymentOutputDescriptorDecodeErrorZ_OK |
|
| Result_DescriptionCreationErrorZ |
|
| Result_DescriptionCreationErrorZ.Result_DescriptionCreationErrorZ_Err |
|
| Result_DescriptionCreationErrorZ.Result_DescriptionCreationErrorZ_OK |
|
| Result_ErrorMessageDecodeErrorZ |
|
| Result_ErrorMessageDecodeErrorZ.Result_ErrorMessageDecodeErrorZ_Err |
|
| Result_ErrorMessageDecodeErrorZ.Result_ErrorMessageDecodeErrorZ_OK |
|
| Result_FixedPenaltyScorerDecodeErrorZ |
|
| Result_FixedPenaltyScorerDecodeErrorZ.Result_FixedPenaltyScorerDecodeErrorZ_Err |
|
| Result_FixedPenaltyScorerDecodeErrorZ.Result_FixedPenaltyScorerDecodeErrorZ_OK |
|
| Result_FundingCreatedDecodeErrorZ |
|
| Result_FundingCreatedDecodeErrorZ.Result_FundingCreatedDecodeErrorZ_Err |
|
| Result_FundingCreatedDecodeErrorZ.Result_FundingCreatedDecodeErrorZ_OK |
|
| Result_FundingSignedDecodeErrorZ |
|
| Result_FundingSignedDecodeErrorZ.Result_FundingSignedDecodeErrorZ_Err |
|
| Result_FundingSignedDecodeErrorZ.Result_FundingSignedDecodeErrorZ_OK |
|
| Result_GossipTimestampFilterDecodeErrorZ |
|
| Result_GossipTimestampFilterDecodeErrorZ.Result_GossipTimestampFilterDecodeErrorZ_Err |
|
| Result_GossipTimestampFilterDecodeErrorZ.Result_GossipTimestampFilterDecodeErrorZ_OK |
|
| Result_HolderCommitmentTransactionDecodeErrorZ |
|
| Result_HolderCommitmentTransactionDecodeErrorZ.Result_HolderCommitmentTransactionDecodeErrorZ_Err |
|
| Result_HolderCommitmentTransactionDecodeErrorZ.Result_HolderCommitmentTransactionDecodeErrorZ_OK |
|
| Result_HTLCOutputInCommitmentDecodeErrorZ |
|
| Result_HTLCOutputInCommitmentDecodeErrorZ.Result_HTLCOutputInCommitmentDecodeErrorZ_Err |
|
| Result_HTLCOutputInCommitmentDecodeErrorZ.Result_HTLCOutputInCommitmentDecodeErrorZ_OK |
|
| Result_HTLCUpdateDecodeErrorZ |
|
| Result_HTLCUpdateDecodeErrorZ.Result_HTLCUpdateDecodeErrorZ_Err |
|
| Result_HTLCUpdateDecodeErrorZ.Result_HTLCUpdateDecodeErrorZ_OK |
|
| Result_InFlightHtlcsDecodeErrorZ |
|
| Result_InFlightHtlcsDecodeErrorZ.Result_InFlightHtlcsDecodeErrorZ_Err |
|
| Result_InFlightHtlcsDecodeErrorZ.Result_InFlightHtlcsDecodeErrorZ_OK |
|
| Result_InitDecodeErrorZ |
|
| Result_InitDecodeErrorZ.Result_InitDecodeErrorZ_Err |
|
| Result_InitDecodeErrorZ.Result_InitDecodeErrorZ_OK |
|
| Result_InitFeaturesDecodeErrorZ |
|
| Result_InitFeaturesDecodeErrorZ.Result_InitFeaturesDecodeErrorZ_Err |
|
| Result_InitFeaturesDecodeErrorZ.Result_InitFeaturesDecodeErrorZ_OK |
|
| Result_InMemorySignerDecodeErrorZ |
|
| Result_InMemorySignerDecodeErrorZ.Result_InMemorySignerDecodeErrorZ_Err |
|
| Result_InMemorySignerDecodeErrorZ.Result_InMemorySignerDecodeErrorZ_OK |
|
| Result_InvoiceFeaturesDecodeErrorZ |
|
| Result_InvoiceFeaturesDecodeErrorZ.Result_InvoiceFeaturesDecodeErrorZ_Err |
|
| Result_InvoiceFeaturesDecodeErrorZ.Result_InvoiceFeaturesDecodeErrorZ_OK |
|
| Result_InvoiceParseOrSemanticErrorZ |
|
| Result_InvoiceParseOrSemanticErrorZ.Result_InvoiceParseOrSemanticErrorZ_Err |
|
| Result_InvoiceParseOrSemanticErrorZ.Result_InvoiceParseOrSemanticErrorZ_OK |
|
| Result_InvoiceSemanticErrorZ |
|
| Result_InvoiceSemanticErrorZ.Result_InvoiceSemanticErrorZ_Err |
|
| Result_InvoiceSemanticErrorZ.Result_InvoiceSemanticErrorZ_OK |
|
| Result_InvoiceSignOrCreationErrorZ |
|
| Result_InvoiceSignOrCreationErrorZ.Result_InvoiceSignOrCreationErrorZ_Err |
|
| Result_InvoiceSignOrCreationErrorZ.Result_InvoiceSignOrCreationErrorZ_OK |
|
| Result_LockedChannelMonitorNoneZ |
|
| Result_LockedChannelMonitorNoneZ.Result_LockedChannelMonitorNoneZ_Err |
|
| Result_LockedChannelMonitorNoneZ.Result_LockedChannelMonitorNoneZ_OK |
|
| Result_NetAddressDecodeErrorZ |
|
| Result_NetAddressDecodeErrorZ.Result_NetAddressDecodeErrorZ_Err |
|
| Result_NetAddressDecodeErrorZ.Result_NetAddressDecodeErrorZ_OK |
|
| Result_NetworkGraphDecodeErrorZ |
|
| Result_NetworkGraphDecodeErrorZ.Result_NetworkGraphDecodeErrorZ_Err |
|
| Result_NetworkGraphDecodeErrorZ.Result_NetworkGraphDecodeErrorZ_OK |
|
| Result_NodeAliasDecodeErrorZ |
|
| Result_NodeAliasDecodeErrorZ.Result_NodeAliasDecodeErrorZ_Err |
|
| Result_NodeAliasDecodeErrorZ.Result_NodeAliasDecodeErrorZ_OK |
|
| Result_NodeAnnouncementDecodeErrorZ |
|
| Result_NodeAnnouncementDecodeErrorZ.Result_NodeAnnouncementDecodeErrorZ_Err |
|
| Result_NodeAnnouncementDecodeErrorZ.Result_NodeAnnouncementDecodeErrorZ_OK |
|
| Result_NodeAnnouncementInfoDecodeErrorZ |
|
| Result_NodeAnnouncementInfoDecodeErrorZ.Result_NodeAnnouncementInfoDecodeErrorZ_Err |
|
| Result_NodeAnnouncementInfoDecodeErrorZ.Result_NodeAnnouncementInfoDecodeErrorZ_OK |
|
| Result_NodeFeaturesDecodeErrorZ |
|
| Result_NodeFeaturesDecodeErrorZ.Result_NodeFeaturesDecodeErrorZ_Err |
|
| Result_NodeFeaturesDecodeErrorZ.Result_NodeFeaturesDecodeErrorZ_OK |
|
| Result_NodeIdDecodeErrorZ |
|
| Result_NodeIdDecodeErrorZ.Result_NodeIdDecodeErrorZ_Err |
|
| Result_NodeIdDecodeErrorZ.Result_NodeIdDecodeErrorZ_OK |
|
| Result_NodeInfoDecodeErrorZ |
|
| Result_NodeInfoDecodeErrorZ.Result_NodeInfoDecodeErrorZ_Err |
|
| Result_NodeInfoDecodeErrorZ.Result_NodeInfoDecodeErrorZ_OK |
|
| Result_NoneAPIErrorZ |
|
| Result_NoneAPIErrorZ.Result_NoneAPIErrorZ_Err |
|
| Result_NoneAPIErrorZ.Result_NoneAPIErrorZ_OK |
|
| Result_NoneErrorZ |
|
| Result_NoneErrorZ.Result_NoneErrorZ_Err |
|
| Result_NoneErrorZ.Result_NoneErrorZ_OK |
|
| Result_NoneLightningErrorZ |
|
| Result_NoneLightningErrorZ.Result_NoneLightningErrorZ_Err |
|
| Result_NoneLightningErrorZ.Result_NoneLightningErrorZ_OK |
|
| Result_NoneNoneZ |
|
| Result_NoneNoneZ.Result_NoneNoneZ_Err |
|
| Result_NoneNoneZ.Result_NoneNoneZ_OK |
|
| Result_NonePaymentErrorZ |
|
| Result_NonePaymentErrorZ.Result_NonePaymentErrorZ_Err |
|
| Result_NonePaymentErrorZ.Result_NonePaymentErrorZ_OK |
|
| Result_NonePaymentSendFailureZ |
|
| Result_NonePaymentSendFailureZ.Result_NonePaymentSendFailureZ_Err |
|
| Result_NonePaymentSendFailureZ.Result_NonePaymentSendFailureZ_OK |
|
| Result_NonePeerHandleErrorZ |
|
| Result_NonePeerHandleErrorZ.Result_NonePeerHandleErrorZ_Err |
|
| Result_NonePeerHandleErrorZ.Result_NonePeerHandleErrorZ_OK |
|
| Result_NoneRetryableSendFailureZ |
|
| Result_NoneRetryableSendFailureZ.Result_NoneRetryableSendFailureZ_Err |
|
| Result_NoneRetryableSendFailureZ.Result_NoneRetryableSendFailureZ_OK |
|
| Result_NoneSemanticErrorZ |
|
| Result_NoneSemanticErrorZ.Result_NoneSemanticErrorZ_Err |
|
| Result_NoneSemanticErrorZ.Result_NoneSemanticErrorZ_OK |
|
| Result_NoneSendErrorZ |
|
| Result_NoneSendErrorZ.Result_NoneSendErrorZ_Err |
|
| Result_NoneSendErrorZ.Result_NoneSendErrorZ_OK |
|
| Result_OnionMessageDecodeErrorZ |
|
| Result_OnionMessageDecodeErrorZ.Result_OnionMessageDecodeErrorZ_Err |
|
| Result_OnionMessageDecodeErrorZ.Result_OnionMessageDecodeErrorZ_OK |
|
| Result_OpenChannelDecodeErrorZ |
|
| Result_OpenChannelDecodeErrorZ.Result_OpenChannelDecodeErrorZ_Err |
|
| Result_OpenChannelDecodeErrorZ.Result_OpenChannelDecodeErrorZ_OK |
|
| Result_OutPointDecodeErrorZ |
|
| Result_OutPointDecodeErrorZ.Result_OutPointDecodeErrorZ_Err |
|
| Result_OutPointDecodeErrorZ.Result_OutPointDecodeErrorZ_OK |
|
| Result_PayeePubKeyErrorZ |
|
| Result_PayeePubKeyErrorZ.Result_PayeePubKeyErrorZ_Err |
|
| Result_PayeePubKeyErrorZ.Result_PayeePubKeyErrorZ_OK |
|
| Result_PaymentFailureReasonDecodeErrorZ |
|
| Result_PaymentFailureReasonDecodeErrorZ.Result_PaymentFailureReasonDecodeErrorZ_Err |
|
| Result_PaymentFailureReasonDecodeErrorZ.Result_PaymentFailureReasonDecodeErrorZ_OK |
|
| Result_PaymentHashPaymentSendFailureZ |
|
| Result_PaymentHashPaymentSendFailureZ.Result_PaymentHashPaymentSendFailureZ_Err |
|
| Result_PaymentHashPaymentSendFailureZ.Result_PaymentHashPaymentSendFailureZ_OK |
|
| Result_PaymentHashRetryableSendFailureZ |
|
| Result_PaymentHashRetryableSendFailureZ.Result_PaymentHashRetryableSendFailureZ_Err |
|
| Result_PaymentHashRetryableSendFailureZ.Result_PaymentHashRetryableSendFailureZ_OK |
|
| Result_PaymentIdPaymentErrorZ |
|
| Result_PaymentIdPaymentErrorZ.Result_PaymentIdPaymentErrorZ_Err |
|
| Result_PaymentIdPaymentErrorZ.Result_PaymentIdPaymentErrorZ_OK |
|
| Result_PaymentParametersDecodeErrorZ |
|
| Result_PaymentParametersDecodeErrorZ.Result_PaymentParametersDecodeErrorZ_Err |
|
| Result_PaymentParametersDecodeErrorZ.Result_PaymentParametersDecodeErrorZ_OK |
|
| Result_PaymentPreimageAPIErrorZ |
|
| Result_PaymentPreimageAPIErrorZ.Result_PaymentPreimageAPIErrorZ_Err |
|
| Result_PaymentPreimageAPIErrorZ.Result_PaymentPreimageAPIErrorZ_OK |
|
| Result_PaymentPurposeDecodeErrorZ |
|
| Result_PaymentPurposeDecodeErrorZ.Result_PaymentPurposeDecodeErrorZ_Err |
|
| Result_PaymentPurposeDecodeErrorZ.Result_PaymentPurposeDecodeErrorZ_OK |
|
| Result_PaymentSecretAPIErrorZ |
|
| Result_PaymentSecretAPIErrorZ.Result_PaymentSecretAPIErrorZ_Err |
|
| Result_PaymentSecretAPIErrorZ.Result_PaymentSecretAPIErrorZ_OK |
|
| Result_PaymentSecretNoneZ |
|
| Result_PaymentSecretNoneZ.Result_PaymentSecretNoneZ_Err |
|
| Result_PaymentSecretNoneZ.Result_PaymentSecretNoneZ_OK |
|
| Result_PhantomRouteHintsDecodeErrorZ |
|
| Result_PhantomRouteHintsDecodeErrorZ.Result_PhantomRouteHintsDecodeErrorZ_Err |
|
| Result_PhantomRouteHintsDecodeErrorZ.Result_PhantomRouteHintsDecodeErrorZ_OK |
|
| Result_PingDecodeErrorZ |
|
| Result_PingDecodeErrorZ.Result_PingDecodeErrorZ_Err |
|
| Result_PingDecodeErrorZ.Result_PingDecodeErrorZ_OK |
|
| Result_PongDecodeErrorZ |
|
| Result_PongDecodeErrorZ.Result_PongDecodeErrorZ_Err |
|
| Result_PongDecodeErrorZ.Result_PongDecodeErrorZ_OK |
|
| Result_PositiveTimestampCreationErrorZ |
|
| Result_PositiveTimestampCreationErrorZ.Result_PositiveTimestampCreationErrorZ_Err |
|
| Result_PositiveTimestampCreationErrorZ.Result_PositiveTimestampCreationErrorZ_OK |
|
| Result_PrivateRouteCreationErrorZ |
|
| Result_PrivateRouteCreationErrorZ.Result_PrivateRouteCreationErrorZ_Err |
|
| Result_PrivateRouteCreationErrorZ.Result_PrivateRouteCreationErrorZ_OK |
|
| Result_ProbabilisticScorerDecodeErrorZ |
|
| Result_ProbabilisticScorerDecodeErrorZ.Result_ProbabilisticScorerDecodeErrorZ_Err |
|
| Result_ProbabilisticScorerDecodeErrorZ.Result_ProbabilisticScorerDecodeErrorZ_OK |
|
| Result_PublicKeyErrorZ |
|
| Result_PublicKeyErrorZ.Result_PublicKeyErrorZ_Err |
|
| Result_PublicKeyErrorZ.Result_PublicKeyErrorZ_OK |
|
| Result_PublicKeyNoneZ |
|
| Result_PublicKeyNoneZ.Result_PublicKeyNoneZ_Err |
|
| Result_PublicKeyNoneZ.Result_PublicKeyNoneZ_OK |
|
| Result_QueryChannelRangeDecodeErrorZ |
|
| Result_QueryChannelRangeDecodeErrorZ.Result_QueryChannelRangeDecodeErrorZ_Err |
|
| Result_QueryChannelRangeDecodeErrorZ.Result_QueryChannelRangeDecodeErrorZ_OK |
|
| Result_QueryShortChannelIdsDecodeErrorZ |
|
| Result_QueryShortChannelIdsDecodeErrorZ.Result_QueryShortChannelIdsDecodeErrorZ_Err |
|
| Result_QueryShortChannelIdsDecodeErrorZ.Result_QueryShortChannelIdsDecodeErrorZ_OK |
|
| Result_RecipientOnionFieldsDecodeErrorZ |
|
| Result_RecipientOnionFieldsDecodeErrorZ.Result_RecipientOnionFieldsDecodeErrorZ_Err |
|
| Result_RecipientOnionFieldsDecodeErrorZ.Result_RecipientOnionFieldsDecodeErrorZ_OK |
|
| Result_RecoverableSignatureNoneZ |
|
| Result_RecoverableSignatureNoneZ.Result_RecoverableSignatureNoneZ_Err |
|
| Result_RecoverableSignatureNoneZ.Result_RecoverableSignatureNoneZ_OK |
|
| Result_ReplyChannelRangeDecodeErrorZ |
|
| Result_ReplyChannelRangeDecodeErrorZ.Result_ReplyChannelRangeDecodeErrorZ_Err |
|
| Result_ReplyChannelRangeDecodeErrorZ.Result_ReplyChannelRangeDecodeErrorZ_OK |
|
| Result_ReplyShortChannelIdsEndDecodeErrorZ |
|
| Result_ReplyShortChannelIdsEndDecodeErrorZ.Result_ReplyShortChannelIdsEndDecodeErrorZ_Err |
|
| Result_ReplyShortChannelIdsEndDecodeErrorZ.Result_ReplyShortChannelIdsEndDecodeErrorZ_OK |
|
| Result_RevokeAndACKDecodeErrorZ |
|
| Result_RevokeAndACKDecodeErrorZ.Result_RevokeAndACKDecodeErrorZ_Err |
|
| Result_RevokeAndACKDecodeErrorZ.Result_RevokeAndACKDecodeErrorZ_OK |
|
| Result_RouteDecodeErrorZ |
|
| Result_RouteDecodeErrorZ.Result_RouteDecodeErrorZ_Err |
|
| Result_RouteDecodeErrorZ.Result_RouteDecodeErrorZ_OK |
|
| Result_RouteHintDecodeErrorZ |
|
| Result_RouteHintDecodeErrorZ.Result_RouteHintDecodeErrorZ_Err |
|
| Result_RouteHintDecodeErrorZ.Result_RouteHintDecodeErrorZ_OK |
|
| Result_RouteHintHopDecodeErrorZ |
|
| Result_RouteHintHopDecodeErrorZ.Result_RouteHintHopDecodeErrorZ_Err |
|
| Result_RouteHintHopDecodeErrorZ.Result_RouteHintHopDecodeErrorZ_OK |
|
| Result_RouteHopDecodeErrorZ |
|
| Result_RouteHopDecodeErrorZ.Result_RouteHopDecodeErrorZ_Err |
|
| Result_RouteHopDecodeErrorZ.Result_RouteHopDecodeErrorZ_OK |
|
| Result_RouteLightningErrorZ |
|
| Result_RouteLightningErrorZ.Result_RouteLightningErrorZ_Err |
|
| Result_RouteLightningErrorZ.Result_RouteLightningErrorZ_OK |
|
| Result_RouteParametersDecodeErrorZ |
|
| Result_RouteParametersDecodeErrorZ.Result_RouteParametersDecodeErrorZ_Err |
|
| Result_RouteParametersDecodeErrorZ.Result_RouteParametersDecodeErrorZ_OK |
|
| Result_RoutingFeesDecodeErrorZ |
|
| Result_RoutingFeesDecodeErrorZ.Result_RoutingFeesDecodeErrorZ_Err |
|
| Result_RoutingFeesDecodeErrorZ.Result_RoutingFeesDecodeErrorZ_OK |
|
| Result_SharedSecretNoneZ |
|
| Result_SharedSecretNoneZ.Result_SharedSecretNoneZ_Err |
|
| Result_SharedSecretNoneZ.Result_SharedSecretNoneZ_OK |
|
| Result_ShutdownDecodeErrorZ |
|
| Result_ShutdownDecodeErrorZ.Result_ShutdownDecodeErrorZ_Err |
|
| Result_ShutdownDecodeErrorZ.Result_ShutdownDecodeErrorZ_OK |
|
| Result_ShutdownScriptDecodeErrorZ |
|
| Result_ShutdownScriptDecodeErrorZ.Result_ShutdownScriptDecodeErrorZ_Err |
|
| Result_ShutdownScriptDecodeErrorZ.Result_ShutdownScriptDecodeErrorZ_OK |
|
| Result_ShutdownScriptInvalidShutdownScriptZ |
|
| Result_ShutdownScriptInvalidShutdownScriptZ.Result_ShutdownScriptInvalidShutdownScriptZ_Err |
|
| Result_ShutdownScriptInvalidShutdownScriptZ.Result_ShutdownScriptInvalidShutdownScriptZ_OK |
|
| Result_SignatureNoneZ |
|
| Result_SignatureNoneZ.Result_SignatureNoneZ_Err |
|
| Result_SignatureNoneZ.Result_SignatureNoneZ_OK |
|
| Result_SignedRawInvoiceParseErrorZ |
|
| Result_SignedRawInvoiceParseErrorZ.Result_SignedRawInvoiceParseErrorZ_Err |
|
| Result_SignedRawInvoiceParseErrorZ.Result_SignedRawInvoiceParseErrorZ_OK |
|
| Result_SiPrefixParseErrorZ |
|
| Result_SiPrefixParseErrorZ.Result_SiPrefixParseErrorZ_Err |
|
| Result_SiPrefixParseErrorZ.Result_SiPrefixParseErrorZ_OK |
|
| Result_SpendableOutputDescriptorDecodeErrorZ |
|
| Result_SpendableOutputDescriptorDecodeErrorZ.Result_SpendableOutputDescriptorDecodeErrorZ_Err |
|
| Result_SpendableOutputDescriptorDecodeErrorZ.Result_SpendableOutputDescriptorDecodeErrorZ_OK |
|
| Result_StaticPaymentOutputDescriptorDecodeErrorZ |
|
| Result_StaticPaymentOutputDescriptorDecodeErrorZ.Result_StaticPaymentOutputDescriptorDecodeErrorZ_Err |
|
| Result_StaticPaymentOutputDescriptorDecodeErrorZ.Result_StaticPaymentOutputDescriptorDecodeErrorZ_OK |
|
| Result_StringErrorZ |
|
| Result_StringErrorZ.Result_StringErrorZ_Err |
|
| Result_StringErrorZ.Result_StringErrorZ_OK |
|
| Result_TransactionNoneZ |
|
| Result_TransactionNoneZ.Result_TransactionNoneZ_Err |
|
| Result_TransactionNoneZ.Result_TransactionNoneZ_OK |
|
| Result_TrustedClosingTransactionNoneZ |
|
| Result_TrustedClosingTransactionNoneZ.Result_TrustedClosingTransactionNoneZ_Err |
|
| Result_TrustedClosingTransactionNoneZ.Result_TrustedClosingTransactionNoneZ_OK |
|
| Result_TrustedCommitmentTransactionNoneZ |
|
| Result_TrustedCommitmentTransactionNoneZ.Result_TrustedCommitmentTransactionNoneZ_Err |
|
| Result_TrustedCommitmentTransactionNoneZ.Result_TrustedCommitmentTransactionNoneZ_OK |
|
| Result_TxCreationKeysDecodeErrorZ |
|
| Result_TxCreationKeysDecodeErrorZ.Result_TxCreationKeysDecodeErrorZ_Err |
|
| Result_TxCreationKeysDecodeErrorZ.Result_TxCreationKeysDecodeErrorZ_OK |
|
| Result_TxOutUtxoLookupErrorZ |
|
| Result_TxOutUtxoLookupErrorZ.Result_TxOutUtxoLookupErrorZ_Err |
|
| Result_TxOutUtxoLookupErrorZ.Result_TxOutUtxoLookupErrorZ_OK |
|
| Result_u32GraphSyncErrorZ |
|
| Result_u32GraphSyncErrorZ.Result_u32GraphSyncErrorZ_Err |
|
| Result_u32GraphSyncErrorZ.Result_u32GraphSyncErrorZ_OK |
|
| Result_UnsignedChannelAnnouncementDecodeErrorZ |
|
| Result_UnsignedChannelAnnouncementDecodeErrorZ.Result_UnsignedChannelAnnouncementDecodeErrorZ_Err |
|
| Result_UnsignedChannelAnnouncementDecodeErrorZ.Result_UnsignedChannelAnnouncementDecodeErrorZ_OK |
|
| Result_UnsignedChannelUpdateDecodeErrorZ |
|
| Result_UnsignedChannelUpdateDecodeErrorZ.Result_UnsignedChannelUpdateDecodeErrorZ_Err |
|
| Result_UnsignedChannelUpdateDecodeErrorZ.Result_UnsignedChannelUpdateDecodeErrorZ_OK |
|
| Result_UnsignedNodeAnnouncementDecodeErrorZ |
|
| Result_UnsignedNodeAnnouncementDecodeErrorZ.Result_UnsignedNodeAnnouncementDecodeErrorZ_Err |
|
| Result_UnsignedNodeAnnouncementDecodeErrorZ.Result_UnsignedNodeAnnouncementDecodeErrorZ_OK |
|
| Result_UntrustedStringDecodeErrorZ |
|
| Result_UntrustedStringDecodeErrorZ.Result_UntrustedStringDecodeErrorZ_Err |
|
| Result_UntrustedStringDecodeErrorZ.Result_UntrustedStringDecodeErrorZ_OK |
|
| Result_UpdateAddHTLCDecodeErrorZ |
|
| Result_UpdateAddHTLCDecodeErrorZ.Result_UpdateAddHTLCDecodeErrorZ_Err |
|
| Result_UpdateAddHTLCDecodeErrorZ.Result_UpdateAddHTLCDecodeErrorZ_OK |
|
| Result_UpdateFailHTLCDecodeErrorZ |
|
| Result_UpdateFailHTLCDecodeErrorZ.Result_UpdateFailHTLCDecodeErrorZ_Err |
|
| Result_UpdateFailHTLCDecodeErrorZ.Result_UpdateFailHTLCDecodeErrorZ_OK |
|
| Result_UpdateFailMalformedHTLCDecodeErrorZ |
|
| Result_UpdateFailMalformedHTLCDecodeErrorZ.Result_UpdateFailMalformedHTLCDecodeErrorZ_Err |
|
| Result_UpdateFailMalformedHTLCDecodeErrorZ.Result_UpdateFailMalformedHTLCDecodeErrorZ_OK |
|
| Result_UpdateFeeDecodeErrorZ |
|
| Result_UpdateFeeDecodeErrorZ.Result_UpdateFeeDecodeErrorZ_Err |
|
| Result_UpdateFeeDecodeErrorZ.Result_UpdateFeeDecodeErrorZ_OK |
|
| Result_UpdateFulfillHTLCDecodeErrorZ |
|
| Result_UpdateFulfillHTLCDecodeErrorZ.Result_UpdateFulfillHTLCDecodeErrorZ_Err |
|
| Result_UpdateFulfillHTLCDecodeErrorZ.Result_UpdateFulfillHTLCDecodeErrorZ_OK |
|
| Result_WarningMessageDecodeErrorZ |
|
| Result_WarningMessageDecodeErrorZ.Result_WarningMessageDecodeErrorZ_Err |
|
| Result_WarningMessageDecodeErrorZ.Result_WarningMessageDecodeErrorZ_OK |
|
| Result_WriteableEcdsaChannelSignerDecodeErrorZ |
|
| Result_WriteableEcdsaChannelSignerDecodeErrorZ.Result_WriteableEcdsaChannelSignerDecodeErrorZ_Err |
|
| Result_WriteableEcdsaChannelSignerDecodeErrorZ.Result_WriteableEcdsaChannelSignerDecodeErrorZ_OK |
|
| Retry |
Strategies available to retry payment path failures.
|
| Retry.Attempts |
Max number of attempts to retry payment.
|
| Retry.Timeout |
Time elapsed before abandoning retries for a payment.
|
| RetryableSendFailure |
Indicates an immediate error on [`ChannelManager::send_payment`].
|
| RevokeAndACK |
A [`revoke_and_ack`] message to be sent to or received from a peer.
|
| Route |
A route directs a payment from the sender (us) to the recipient.
|
| RouteHint |
A list of hops along a payment path terminating with a channel to the recipient.
|
| RouteHintHop |
A channel descriptor for a hop along a payment path.
|
| RouteHop |
A hop in a route, and additional metadata about it.
|
| RouteParameters |
Parameters needed to find a [`Route`].
|
| Router |
A trait defining behavior for routing a payment.
|
| Router.RouterInterface |
|
| RoutingFees |
Fees for routing via a given channel or a node
|
| RoutingMessageHandler |
A trait to describe an object which can receive routing messages.
|
| RoutingMessageHandler.RoutingMessageHandlerInterface |
|
| Score |
An interface used to score payment channels for path finding.
|
| Score.ScoreInterface |
|
| ScorerAccountingForInFlightHtlcs |
[`Score`] implementation that factors in in-flight HTLC liquidity.
|
| Secp256k1Error |
Represents an error returned from libsecp256k1 during validation of some secp256k1 data
|
| SemanticError |
Errors that may occur when converting a [`RawInvoice`] to an [`Invoice`].
|
| SendError |
Errors that may occur when [sending an onion message].
|
| SendError.BlindedPathAdvanceFailed |
We attempted to send to a blinded path where we are the introduction node, and failed to
advance the blinded path to make the second hop the new introduction node.
|
| SendError.BufferFull |
Our next-hop peer's buffer was full or our total outbound buffer was full.
|
| SendError.GetNodeIdFailed |
Failed to retrieve our node id from the provided [`NodeSigner`].
|
| SendError.InvalidFirstHop |
Our next-hop peer was offline or does not support onion message forwarding.
|
| SendError.InvalidMessage |
Onion message contents must have a TLV type >= 64.
|
| SendError.Secp256k1 |
Errored computing onion message packet keys.
|
| SendError.TooBigPacket |
Because implementations such as Eclair will drop onion messages where the message packet
exceeds 32834 bytes, we refuse to send messages where the packet exceeds this size.
|
| SendError.TooFewBlindedHops |
The provided [`Destination`] was an invalid [`BlindedPath`], due to having fewer than two
blinded hops.
|
| Sha256 |
SHA-256 hash
|
| Shutdown |
A [`shutdown`] message to be sent to or received from a peer.
|
| ShutdownScript |
A script pubkey for shutting down a channel as defined by [BOLT #2].
|
| SignedRawInvoice |
Represents a signed [`RawInvoice`] with cached hash.
|
| SignerProvider |
A trait that can return signer instances for individual channels.
|
| SignerProvider.SignerProviderInterface |
|
| SignOrCreationError |
When signing using a fallible method either an user-supplied `SignError` or a [`CreationError`]
may occur.
|
| SignOrCreationError.CreationError |
An error occurred while building the transaction
|
| SignOrCreationError.SignError |
An error occurred during signing
|
| SiPrefix |
SI prefixes for the human readable part
|
| Sleeper |
A struct which can be used to select across many [`Future`]s at once without relying on a full
async context.
|
| SocketDescriptor |
Provides an object which can be used to send data to and which uniquely identifies a connection
to a remote host.
|
| SocketDescriptor.SocketDescriptorInterface |
|
| SpendableOutputDescriptor |
Describes the necessary information to spend a spendable output.
|
| SpendableOutputDescriptor.DelayedPaymentOutput |
An output to a P2WSH script which can be spent with a single signature after an `OP_CSV`
delay.
|
| SpendableOutputDescriptor.StaticOutput |
An output to a script which was provided via [`SignerProvider`] directly, either from
[`get_destination_script`] or [`get_shutdown_scriptpubkey`], thus you should already
know how to spend it.
|
| SpendableOutputDescriptor.StaticPaymentOutput |
An output to a P2WPKH, spendable exclusively by our payment key (i.e., the private key
which corresponds to the `payment_point` in [`ChannelSigner::pubkeys`]).
|
| StaticPaymentOutputDescriptor |
Information about a spendable output to our \"payment key\".
|
| ThreeTuple<A,B,C> |
|
| ThreeTuple_ChannelAnnouncementChannelUpdateChannelUpdateZ |
A Tuple
|
| ThreeTuple_OutPointCVec_MonitorEventZPublicKeyZ |
A Tuple
|
| ThreeTuple_RawInvoice_u832InvoiceSignatureZ |
A Tuple
|
| TrustedClosingTransaction |
A wrapper on ClosingTransaction indicating that the built bitcoin
transaction is trusted.
|
| TrustedCommitmentTransaction |
A wrapper on CommitmentTransaction indicating that the derived fields (the built bitcoin
transaction and the transaction creation keys) are trusted.
|
| TwoTuple<A,B> |
|
| TwoTuple__u168_u168Z |
A Tuple
|
| TwoTuple_BlindedPayInfoBlindedPathZ |
A Tuple
|
| TwoTuple_BlockHashChannelManagerZ |
A Tuple
|
| TwoTuple_BlockHashChannelMonitorZ |
A Tuple
|
| TwoTuple_OutPointCVec_MonitorUpdateIdZZ |
A Tuple
|
| TwoTuple_OutPointScriptZ |
A Tuple
|
| TwoTuple_PaymentHashPaymentIdZ |
A Tuple
|
| TwoTuple_PaymentHashPaymentSecretZ |
A Tuple
|
| TwoTuple_PublicKeyCOption_NetAddressZZ |
A Tuple
|
| TwoTuple_PublicKeyTypeZ |
A Tuple
|
| TwoTuple_SignatureCVec_SignatureZZ |
A Tuple
|
| TwoTuple_TxidBlockHashZ |
A Tuple
|
| TwoTuple_TxidCVec_C2Tuple_u32ScriptZZZ |
A Tuple
|
| TwoTuple_TxidCVec_C2Tuple_u32TxOutZZZ |
A Tuple
|
| TwoTuple_u32ScriptZ |
A Tuple
|
| TwoTuple_u32TxOutZ |
A Tuple
|
| TwoTuple_u64u64Z |
A Tuple
|
| TwoTuple_usizeTransactionZ |
A Tuple
|
| TwoTuple_Z |
A Tuple
|
| TxCreationKeys |
The set of public keys which are used in the creation of one commitment transaction.
|
| TxOut |
|
| Type |
Defines a type identifier for sending messages over the wire.
|
| Type.TypeInterface |
|
| UInt128 |
A 5-bit unsigned integer
|
| UInt5 |
A 5-bit unsigned integer
|
| UnqualifiedError |
An type for cases where no additional information is available.
|
| UnsignedChannelAnnouncement |
The unsigned part of a [`channel_announcement`] message.
|
| UnsignedChannelUpdate |
The unsigned part of a [`channel_update`] message.
|
| UnsignedGossipMessage |
Represents the set of gossip messages that require a signature from a node's identity key.
|
| UnsignedGossipMessage.ChannelAnnouncement |
An unsigned channel announcement.
|
| UnsignedGossipMessage.ChannelUpdate |
An unsigned channel update.
|
| UnsignedGossipMessage.NodeAnnouncement |
An unsigned node announcement.
|
| UnsignedInvoice |
A semantically valid [`Invoice`] that hasn't been signed.
|
| UnsignedInvoiceRequest |
A semantically valid [`InvoiceRequest`] that hasn't been signed.
|
| UnsignedNodeAnnouncement |
The unsigned part of a [`node_announcement`] message.
|
| UntrustedString |
Struct to `Display` fields in a safe way using `PrintableString`
|
| UpdateAddHTLC |
An [`update_add_htlc`] message to be sent to or received from a peer.
|
| UpdateFailHTLC |
An [`update_fail_htlc`] message to be sent to or received from a peer.
|
| UpdateFailMalformedHTLC |
An [`update_fail_malformed_htlc`] message to be sent to or received from a peer.
|
| UpdateFee |
An [`update_fee`] message to be sent to or received from a peer
[`update_fee`]: https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#updating-fees-update_fee
|
| UpdateFulfillHTLC |
An [`update_fulfill_htlc`] message to be sent to or received from a peer.
|
| UserConfig |
Top-level config which holds ChannelHandshakeLimits and ChannelConfig.
|
| UtilMethods |
|
| UtxoFuture |
Represents a future resolution of a [`UtxoLookup::get_utxo`] query resolving async.
|
| UtxoLookup |
The `UtxoLookup` trait defines behavior for accessing on-chain UTXOs.
|
| UtxoLookup.UtxoLookupInterface |
|
| UtxoLookupError |
An error when accessing the chain via [`UtxoLookup`].
|
| UtxoResult |
The result of a [`UtxoLookup::get_utxo`] call.
|
| UtxoResult.Async |
A result which will be resolved asynchronously.
|
| UtxoResult.Sync |
A result which was resolved synchronously.
|
| version |
|
| WarningMessage |
A [`warning`] message to be sent to or received from a peer.
|
| Watch |
The `Watch` trait defines behavior for watching on-chain activity pertaining to channels as
blocks are connected and disconnected.
|
| Watch.WatchInterface |
|
| WatchedOutput |
A transaction output watched by a [`ChannelMonitor`] for spends on-chain.
|
| WitnessVersion |
A 4-bit unsigned integer representing a Bitcoin SegWit version
|
| WriteableEcdsaChannelSigner |
A writeable signer.
|
| WriteableEcdsaChannelSigner.WriteableEcdsaChannelSignerInterface |
|
| WriteableScore |
Refers to a scorer that is accessible under lock and also writeable to disk
We need this trait to be able to pass in a scorer to `lightning-background-processor` that will enable us to
use the Persister to persist it.
|
| WriteableScore.WriteableScoreInterface |
|