Documentation
¶
Index ¶
- Constants
- Variables
- func DisableLog()
- func EncodeHexColor(color color.RGBA) string
- func IsError(e interface{}, codes ...errorCode) bool
- func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (map[route.Vertex][]*channeldb.CachedEdgePolicy, error)
- func UseLogger(logger btclog.Logger)
- func ValidateCLTVLimit(limit uint32, delta uint16, includePad bool) error
- func ValidateChannelAnn(a *lnwire.ChannelAnnouncement) error
- func ValidateChannelUpdateAnn(pubKey *btcec.PublicKey, capacity btcutil.Amount, a *lnwire.ChannelUpdate) error
- func ValidateChannelUpdateFields(capacity btcutil.Amount, msg *lnwire.ChannelUpdate) error
- func ValidateNodeAnn(a *lnwire.NodeAnnouncement) error
- func VerifyChannelUpdateSignature(msg *lnwire.ChannelUpdate, pubKey *btcec.PublicKey) error
- type AMPOptions
- type AprioriConfig
- type AprioriEstimator
- func (p *AprioriEstimator) Config() estimatorConfig
- func (p *AprioriEstimator) LocalPairProbability(now time.Time, results NodeResults, toNode route.Vertex) float64
- func (p *AprioriEstimator) PairProbability(now time.Time, results NodeResults, toNode route.Vertex, ...) float64
- func (p *AprioriEstimator) String() string
- type BimodalConfig
- type BimodalEstimator
- func (p *BimodalEstimator) Config() estimatorConfig
- func (p *BimodalEstimator) LocalPairProbability(now time.Time, results NodeResults, toNode route.Vertex) float64
- func (p *BimodalEstimator) PairProbability(now time.Time, results NodeResults, toNode route.Vertex, ...) float64
- func (p *BimodalEstimator) String() string
- type CachedGraph
- type ChannelEdgeUpdate
- type ChannelGraphSource
- type ChannelPolicy
- type ChannelRouter
- func (r *ChannelRouter) AddEdge(edge *channeldb.ChannelEdgeInfo, op ...batch.SchedulerOption) error
- func (r *ChannelRouter) AddNode(node *channeldb.LightningNode, op ...batch.SchedulerOption) error
- func (r *ChannelRouter) AddProof(chanID lnwire.ShortChannelID, proof *channeldb.ChannelAuthProof) error
- func (r *ChannelRouter) BuildRoute(amt *lnwire.MilliSatoshi, hops []route.Vertex, outgoingChan *uint64, ...) (*route.Route, error)
- func (r *ChannelRouter) CurrentBlockHeight() (uint32, error)
- func (r *ChannelRouter) FetchLightningNode(node route.Vertex) (*channeldb.LightningNode, error)
- func (r *ChannelRouter) FindRoute(source, target route.Vertex, amt lnwire.MilliSatoshi, timePref float64, ...) (*route.Route, float64, error)
- func (r *ChannelRouter) ForAllOutgoingChannels(...) error
- func (r *ChannelRouter) ForEachNode(cb func(*channeldb.LightningNode) error) error
- func (r *ChannelRouter) GetChannelByID(chanID lnwire.ShortChannelID) (*channeldb.ChannelEdgeInfo, *channeldb.ChannelEdgePolicy, ...)
- func (r *ChannelRouter) IsKnownEdge(chanID lnwire.ShortChannelID) bool
- func (r *ChannelRouter) IsPublicNode(node route.Vertex) (bool, error)
- func (r *ChannelRouter) IsStaleEdgePolicy(chanID lnwire.ShortChannelID, timestamp time.Time, ...) bool
- func (r *ChannelRouter) IsStaleNode(node route.Vertex, timestamp time.Time) bool
- func (r *ChannelRouter) MarkEdgeLive(chanID lnwire.ShortChannelID) error
- func (r *ChannelRouter) SendPayment(payment *LightningPayment) ([32]byte, *route.Route, error)
- func (r *ChannelRouter) SendPaymentAsync(payment *LightningPayment) error
- func (r *ChannelRouter) SendToRoute(htlcHash lntypes.Hash, rt *route.Route) (*channeldb.HTLCAttempt, error)
- func (r *ChannelRouter) SendToRouteSkipTempErr(htlcHash lntypes.Hash, rt *route.Route) (*channeldb.HTLCAttempt, error)
- func (r *ChannelRouter) Start() error
- func (r *ChannelRouter) Stop() error
- func (r *ChannelRouter) SubscribeTopology() (*TopologyClient, error)
- func (r *ChannelRouter) SyncedHeight() uint32
- func (r *ChannelRouter) UpdateEdge(update *channeldb.ChannelEdgePolicy, op ...batch.SchedulerOption) error
- type ClosedChanSummary
- type Config
- type ControlTower
- type ControlTowerSubscriber
- type DirectedNodePair
- type EdgeLocator
- type ErrNoChannel
- type Estimator
- type FeeSchema
- type LightningPayment
- type MissionControl
- func (m *MissionControl) GetConfig() *MissionControlConfig
- func (m *MissionControl) GetHistorySnapshot() *MissionControlSnapshot
- func (m *MissionControl) GetPairHistorySnapshot(fromNode, toNode route.Vertex) TimedPairResult
- func (m *MissionControl) GetProbability(fromNode, toNode route.Vertex, amt lnwire.MilliSatoshi, ...) float64
- func (m *MissionControl) ImportHistory(history *MissionControlSnapshot, force bool) error
- func (m *MissionControl) ReportPaymentFail(paymentID uint64, rt *route.Route, failureSourceIdx *int, ...) (*channeldb.FailureReason, error)
- func (m *MissionControl) ReportPaymentSuccess(paymentID uint64, rt *route.Route) error
- func (m *MissionControl) ResetHistory() error
- func (m *MissionControl) RunStoreTicker()
- func (m *MissionControl) SetConfig(cfg *MissionControlConfig) error
- func (m *MissionControl) StopStoreTicker()
- type MissionControlConfig
- type MissionControlPairSnapshot
- type MissionControlSnapshot
- type MissionController
- type NetworkNodeUpdate
- type NodeResults
- type PathFindingConfig
- type PaymentAttemptDispatcher
- type PaymentSession
- type PaymentSessionSource
- type RestrictParams
- type SessionSource
- type TimedPairResult
- type TopologyChange
- type TopologyClient
- type ValidationBarrier
Constants ¶
const ( // ErrOutdated is returned when the routing update already have // been applied, or a newer update is already known. ErrOutdated errorCode = iota // ErrIgnored is returned when the update have been ignored because // this update can't bring us something new, or because a node // announcement was given for node not found in any channel. ErrIgnored // ErrChannelSpent is returned when we go to validate a channel, but // the purported funding output has actually already been spent on // chain. ErrChannelSpent // ErrNoFundingTransaction is returned when we are unable to find the // funding transaction described by the short channel ID on chain. ErrNoFundingTransaction // ErrInvalidFundingOutput is returned if the channel funding output // fails validation. ErrInvalidFundingOutput // ErrVBarrierShuttingDown signals that the barrier has been requested // to shutdown, and that the caller should not treat the wait condition // as fulfilled. ErrVBarrierShuttingDown // ErrParentValidationFailed signals that the validation of a // dependent's parent failed, so the dependent must not be processed. ErrParentValidationFailed )
const ( // DefaultPenaltyHalfLife is the default half-life duration. The // half-life duration defines after how much time a penalized node or // channel is back at 50% probability. DefaultPenaltyHalfLife = time.Hour // DefaultMaxMcHistory is the default maximum history size. DefaultMaxMcHistory = 1000 // DefaultMcFlushInterval is the default interval we use to flush MC state // to the database. DefaultMcFlushInterval = time.Second // DefaultAprioriWeight is the default a priori weight. See // MissionControlConfig for further explanation. DefaultAprioriWeight = 0.5 // DefaultMinFailureRelaxInterval is the default minimum time that must // have passed since the previously recorded failure before the failure // amount may be raised. DefaultMinFailureRelaxInterval = time.Minute )
const ( // DefaultCapacityFraction is the default value for CapacityFraction. // It is chosen such that the capacity factor is active but with a small // effect. This value together with capacitySmearingFraction leads to a // noticeable reduction in probability if the amount starts to come // close to 90% of a channel's capacity. DefaultCapacityFraction = 0.9999 // AprioriEstimatorName is used to identify the apriori probability // estimator. AprioriEstimatorName = "apriori" )
const ( // DefaultBimodalScaleMsat is the default value for BimodalScaleMsat in // BimodalConfig. It describes the distribution of funds in the LN based // on empirical findings. We assume an unbalanced network by default. DefaultBimodalScaleMsat = lnwire.MilliSatoshi(300_000_000) // DefaultBimodalNodeWeight is the default value for the // BimodalNodeWeight in BimodalConfig. It is chosen such that past // forwardings on other channels of a router are only slightly taken // into account. DefaultBimodalNodeWeight = 0.2 // DefaultBimodalDecayTime is the default value for BimodalDecayTime. // We will forget about previous learnings about channel liquidity on // the timescale of about a week. DefaultBimodalDecayTime = 7 * 24 * time.Hour // BimodalScaleMsatLimit is the maximum value for BimodalScaleMsat to // avoid numerical issues. BimodalScaleMsatMax = lnwire.MilliSatoshi(21e17) // BimodalEstimatorName is used to identify the bimodal estimator. BimodalEstimatorName = "bimodal" )
const ( // DefaultPayAttemptTimeout is the default payment attempt timeout. The // payment attempt timeout defines the duration after which we stop // trying more routes for a payment. DefaultPayAttemptTimeout = time.Duration(time.Second * 60) // DefaultChannelPruneExpiry is the default duration used to determine // if a channel should be pruned or not. DefaultChannelPruneExpiry = time.Duration(time.Hour * 24 * 14) // DefaultFirstTimePruneDelay is the time we'll wait after startup // before attempting to prune the graph for zombie channels. We don't // do it immediately after startup to allow lnd to start up without // getting blocked by this job. DefaultFirstTimePruneDelay = 30 * time.Second // MinCLTVDelta is the minimum CLTV value accepted by LND for all // timelock deltas. This includes both forwarding CLTV deltas set on // channel updates, as well as final CLTV deltas used to create BOLT 11 // payment requests. // // NOTE: For payment requests, BOLT 11 stipulates that a final CLTV // delta of 9 should be used when no value is decoded. This however // leads to inflexiblity in upgrading this default parameter, since it // can create inconsistencies around the assumed value between sender // and receiver. Specifically, if the receiver assumes a higher value // than the sender, the receiver will always see the received HTLCs as // invalid due to their timelock not meeting the required delta. // // We skirt this by always setting an explicit CLTV delta when creating // invoices. This allows LND nodes to freely update the minimum without // creating incompatibilities during the upgrade process. For some time // LND has used an explicit default final CLTV delta of 40 blocks for // bitcoin (160 for litecoin), though we now clamp the lower end of this // range for user-chosen deltas to 18 blocks to be conservative. MinCLTVDelta = 18 )
const BlockPadding uint16 = 3
BlockPadding is used to increment the finalCltvDelta value for the last hop to prevent an HTLC being failed if some blocks are mined while it's in-flight.
const ( // RiskFactorBillionths controls the influence of time lock delta // of a channel on route selection. It is expressed as billionths // of msat per msat sent through the channel per time lock delta // block. See edgeWeight function below for more details. // The chosen value is based on the previous incorrect weight function // 1 + timelock + fee * fee. In this function, the fee penalty // diminishes the time lock penalty for all but the smallest amounts. // To not change the behaviour of path finding too drastically, a // relatively small value is chosen which is still big enough to give // some effect with smaller time lock values. The value may need // tweaking and/or be made configurable in the future. RiskFactorBillionths = 15 )
const Subsystem = "CRTR"
Variables ¶
var ( // ErrInvalidMcHistory is returned if we get a negative mission control // history count. ErrInvalidMcHistory = errors.New("mission control history must be " + ">= 0") // ErrInvalidFailureInterval is returned if we get an invalid failure // interval. ErrInvalidFailureInterval = errors.New("failure interval must be >= 0") )
var ( // DefaultEstimator is the default estimator used for computing // probabilities in pathfinding. DefaultEstimator = AprioriEstimatorName // DefaultAttemptCost is the default fixed virtual cost in path finding // of a failed payment attempt. It is used to trade off potentially // better routes against their probability of succeeding. DefaultAttemptCost = lnwire.NewMSatFromSatoshis(100) // DefaultAttemptCostPPM is the default proportional virtual cost in // path finding weight units of executing a payment attempt that fails. // It is used to trade off potentially better routes against their // probability of succeeding. This parameter is expressed in parts per // million of the payment amount. // // It is impossible to pick a perfect default value. The current value // of 0.1% is based on the idea that a transaction fee of 1% is within // reasonable territory and that a payment shouldn't need more than 10 // attempts. DefaultAttemptCostPPM = int64(1000) // DefaultMinRouteProbability is the default minimum probability for routes // returned from findPath. DefaultMinRouteProbability = float64(0.01) // DefaultAprioriHopProbability is the default a priori probability for // a hop. DefaultAprioriHopProbability = float64(0.6) )
var ( // ErrInvalidHalflife is returned when we get an invalid half life. ErrInvalidHalflife = errors.New("penalty half life must be >= 0") // ErrInvalidHopProbability is returned when we get an invalid hop // probability. ErrInvalidHopProbability = errors.New("hop probability must be in " + "[0, 1]") // ErrInvalidAprioriWeight is returned when we get an apriori weight // that is out of range. ErrInvalidAprioriWeight = errors.New("apriori weight must be in [0, 1]") // ErrInvalidCapacityFraction is returned when we get a capacity // fraction that is out of range. ErrInvalidCapacityFraction = fmt.Errorf("capacity fraction must be in "+ "[%v, 1]", minCapacityFraction) )
var ( // ErrInvalidScale is returned when we get a scale below or equal zero. ErrInvalidScale = errors.New("scale must be >= 0 and sane") // ErrInvalidNodeWeight is returned when we get a node weight that is // out of range. ErrInvalidNodeWeight = errors.New("node weight must be in [0, 1]") // ErrInvalidDecayTime is returned when we get a decay time below zero. ErrInvalidDecayTime = errors.New("decay time must be larger than zero") )
var ( // DefaultShardMinAmt is the default amount beyond which we won't try to // further split the payment if no route is found. It is the minimum // amount that we use as the shard size when splitting. DefaultShardMinAmt = lnwire.NewMSatFromSatoshis(10000) )
var ( // ErrRouterShuttingDown is returned if the router is in the process of // shutting down. ErrRouterShuttingDown = fmt.Errorf("router shutting down") )
Functions ¶
func DisableLog ¶
func DisableLog()
DisableLog disables all library log output. Logging output is disabled by by default until UseLogger is called.
func EncodeHexColor ¶
EncodeHexColor takes a color and returns it in hex code format.
func IsError ¶
func IsError(e interface{}, codes ...errorCode) bool
IsError is a helper function which is needed to have ability to check that returned error has specific error code.
func RouteHintsToEdges ¶
func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) ( map[route.Vertex][]*channeldb.CachedEdgePolicy, error)
RouteHintsToEdges converts a list of invoice route hints to an edge map that can be passed into pathfinding.
func UseLogger ¶
UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using btclog.
func ValidateCLTVLimit ¶
ValidateCLTVLimit is a helper function that validates that the cltv limit is greater than the final cltv delta parameter, optionally including the BlockPadding in this calculation.
func ValidateChannelAnn ¶
func ValidateChannelAnn(a *lnwire.ChannelAnnouncement) error
ValidateChannelAnn validates the channel announcement message and checks that node signatures covers the announcement message, and that the bitcoin signatures covers the node keys.
func ValidateChannelUpdateAnn ¶
func ValidateChannelUpdateAnn(pubKey *btcec.PublicKey, capacity btcutil.Amount, a *lnwire.ChannelUpdate) error
ValidateChannelUpdateAnn validates the channel update announcement by checking (1) that the included signature covers the announcement and has been signed by the node's private key, and (2) that the announcement's message flags and optional fields are sane.
func ValidateChannelUpdateFields ¶
func ValidateChannelUpdateFields(capacity btcutil.Amount, msg *lnwire.ChannelUpdate) error
ValidateChannelUpdateFields validates a channel update's message flags and corresponding update fields.
func ValidateNodeAnn ¶
func ValidateNodeAnn(a *lnwire.NodeAnnouncement) error
ValidateNodeAnn validates the node announcement by ensuring that the attached signature is needed a signature of the node announcement under the specified node public key.
func VerifyChannelUpdateSignature ¶
func VerifyChannelUpdateSignature(msg *lnwire.ChannelUpdate, pubKey *btcec.PublicKey) error
VerifyChannelUpdateSignature verifies that the channel update message was signed by the party with the given node public key.
Types ¶
type AMPOptions ¶
type AMPOptions struct { SetID [32]byte }
AMPOptions houses information that must be known in order to send an AMP payment.
type AprioriConfig ¶
type AprioriConfig struct { // PenaltyHalfLife defines after how much time a penalized node or // channel is back at 50% probability. PenaltyHalfLife time.Duration // AprioriHopProbability is the assumed success probability of a hop in // a route when no other information is available. AprioriHopProbability float64 // AprioriWeight is a value in the range [0, 1] that defines to what // extent historical results should be extrapolated to untried // connections. Setting it to one will completely ignore historical // results and always assume the configured a priori probability for // untried connections. A value of zero will ignore the a priori // probability completely and only base the probability on historical // results, unless there are none available. AprioriWeight float64 // CapacityFraction is the fraction of a channel's capacity that we // consider to have liquidity. For amounts that come close to or exceed // the fraction, an additional penalty is applied. A value of 1.0 // disables the capacityFactor. CapacityFraction float64 }
AprioriConfig contains configuration for our probability estimator.
func DefaultAprioriConfig ¶
func DefaultAprioriConfig() AprioriConfig
DefaultAprioriConfig returns the default configuration for the estimator.
type AprioriEstimator ¶
type AprioriEstimator struct { // AprioriConfig contains configuration options for our estimator. AprioriConfig // contains filtered or unexported fields }
AprioriEstimator returns node and pair probabilities based on historical payment results. It uses a preconfigured success probability value for untried hops (AprioriHopProbability) and returns a high success probability for hops that could previously conduct a payment (prevSuccessProbability). Successful edges are retried until proven otherwise. Recently failed hops are penalized by an exponential time decay (PenaltyHalfLife), after which they are reconsidered for routing. If information was learned about a forwarding node, the information is taken into account to estimate a per node probability that mixes with the a priori probability (AprioriWeight).
func NewAprioriEstimator ¶
func NewAprioriEstimator(cfg AprioriConfig) (*AprioriEstimator, error)
NewAprioriEstimator creates a new AprioriEstimator.
func (*AprioriEstimator) Config ¶
func (p *AprioriEstimator) Config() estimatorConfig
Config returns the estimator's configuration.
func (*AprioriEstimator) LocalPairProbability ¶
func (p *AprioriEstimator) LocalPairProbability( now time.Time, results NodeResults, toNode route.Vertex) float64
LocalPairProbability estimates the probability of successfully traversing our own local channels to toNode.
func (*AprioriEstimator) PairProbability ¶
func (p *AprioriEstimator) PairProbability(now time.Time, results NodeResults, toNode route.Vertex, amt lnwire.MilliSatoshi, capacity btcutil.Amount) float64
PairProbability estimates the probability of successfully traversing to toNode based on historical payment outcomes for the from node. Those outcomes are passed in via the results parameter.
func (*AprioriEstimator) String ¶
func (p *AprioriEstimator) String() string
String returns the estimator's configuration as a string representation.
type BimodalConfig ¶
type BimodalConfig struct { // BimodalNodeWeight defines how strongly other previous forwardings on // channels of a router should be taken into account when computing a // channel's probability to route. The allowed values are in the range // [0, 1], where a value of 0 means that only direct information about a // channel is taken into account. BimodalNodeWeight float64 // BimodalScaleMsat describes the scale over which channels // statistically have some liquidity left. The value determines how // quickly the bimodal distribution drops off from the edges of a // channel. A larger value (compared to typical channel capacities) // means that the drop off is slow and that channel balances are // distributed more uniformly. A small value leads to the assumption of // very unbalanced channels. BimodalScaleMsat lnwire.MilliSatoshi // BimodalDecayTime is the scale for the exponential information decay // over time for previous successes or failures. BimodalDecayTime time.Duration }
BimodalConfig contains configuration for our probability estimator.
func DefaultBimodalConfig ¶
func DefaultBimodalConfig() BimodalConfig
DefaultBimodalConfig returns the default configuration for the estimator.
type BimodalEstimator ¶
type BimodalEstimator struct { // BimodalConfig contains configuration options for our estimator. BimodalConfig }
BimodalEstimator returns node and pair probabilities based on historical payment results based on a liquidity distribution model of the LN. The main function is to estimate the direct channel probability based on a depleted liquidity distribution model, with additional information decay over time. A per-node probability can be mixed with the direct probability, taking into account successes/failures on other channels of the forwarder.
func NewBimodalEstimator ¶
func NewBimodalEstimator(cfg BimodalConfig) (*BimodalEstimator, error)
NewBimodalEstimator creates a new BimodalEstimator.
func (*BimodalEstimator) Config ¶
func (p *BimodalEstimator) Config() estimatorConfig
config returns the current configuration of the estimator.
func (*BimodalEstimator) LocalPairProbability ¶
func (p *BimodalEstimator) LocalPairProbability(now time.Time, results NodeResults, toNode route.Vertex) float64
LocalPairProbability computes the probability to reach toNode given a set of previous learnings.
func (*BimodalEstimator) PairProbability ¶
func (p *BimodalEstimator) PairProbability(now time.Time, results NodeResults, toNode route.Vertex, amt lnwire.MilliSatoshi, capacity btcutil.Amount) float64
PairProbability estimates the probability of successfully traversing to toNode based on historical payment outcomes for the from node. Those outcomes are passed in via the results parameter.
func (*BimodalEstimator) String ¶
func (p *BimodalEstimator) String() string
String returns the estimator's configuration as a string representation.
type CachedGraph ¶
type CachedGraph struct {
// contains filtered or unexported fields
}
CachedGraph is a routingGraph implementation that retrieves from the database.
func NewCachedGraph ¶
func NewCachedGraph(sourceNode *channeldb.LightningNode, graph *channeldb.ChannelGraph) (*CachedGraph, error)
NewCachedGraph instantiates a new db-connected routing graph. It implicitly instantiates a new read transaction.
func (*CachedGraph) Close ¶
func (g *CachedGraph) Close() error
Close attempts to close the underlying db transaction. This is a no-op in case the underlying graph uses an in-memory cache.
func (*CachedGraph) FetchAmountPairCapacity ¶
func (g *CachedGraph) FetchAmountPairCapacity(nodeFrom, nodeTo route.Vertex, amount lnwire.MilliSatoshi) (btcutil.Amount, error)
FetchAmountPairCapacity determines the maximal public capacity between two nodes depending on the amount we try to send.
NOTE: Part of the routingGraph interface.
type ChannelEdgeUpdate ¶
type ChannelEdgeUpdate struct { // ChanID is the unique short channel ID for the channel. This encodes // where in the blockchain the channel's funding transaction was // originally confirmed. ChanID uint64 // ChanPoint is the outpoint which represents the multi-sig funding // output for the channel. ChanPoint wire.OutPoint // Capacity is the capacity of the newly created channel. Capacity btcutil.Amount // MinHTLC is the minimum HTLC amount that this channel will forward. MinHTLC lnwire.MilliSatoshi // MaxHTLC is the maximum HTLC amount that this channel will forward. MaxHTLC lnwire.MilliSatoshi // BaseFee is the base fee that will charged for all HTLC's forwarded // across the this channel direction. BaseFee lnwire.MilliSatoshi // FeeRate is the fee rate that will be shared for all HTLC's forwarded // across this channel direction. FeeRate lnwire.MilliSatoshi // TimeLockDelta is the time-lock expressed in blocks that will be // added to outgoing HTLC's from incoming HTLC's. This value is the // difference of the incoming and outgoing HTLC's time-locks routed // through this hop. TimeLockDelta uint16 // AdvertisingNode is the node that's advertising this edge. AdvertisingNode *btcec.PublicKey // ConnectingNode is the node that the advertising node connects to. ConnectingNode *btcec.PublicKey // Disabled, if true, signals that the channel is unavailable to relay // payments. Disabled bool }
ChannelEdgeUpdate is an update for a new channel within the ChannelGraph. This update is sent out once a new authenticated channel edge is discovered within the network. These updates are directional, so if a channel is fully public, then there will be two updates sent out: one for each direction within the channel. Each update will carry that particular routing edge policy for the channel direction.
An edge is a channel in the direction of AdvertisingNode -> ConnectingNode.
type ChannelGraphSource ¶
type ChannelGraphSource interface { // AddNode is used to add information about a node to the router // database. If the node with this pubkey is not present in an existing // channel, it will be ignored. AddNode(node *channeldb.LightningNode, op ...batch.SchedulerOption) error // AddEdge is used to add edge/channel to the topology of the router, // after all information about channel will be gathered this // edge/channel might be used in construction of payment path. AddEdge(edge *channeldb.ChannelEdgeInfo, op ...batch.SchedulerOption) error // AddProof updates the channel edge info with proof which is needed to // properly announce the edge to the rest of the network. AddProof(chanID lnwire.ShortChannelID, proof *channeldb.ChannelAuthProof) error // UpdateEdge is used to update edge information, without this message // edge considered as not fully constructed. UpdateEdge(policy *channeldb.ChannelEdgePolicy, op ...batch.SchedulerOption) error // IsStaleNode returns true if the graph source has a node announcement // for the target node with a more recent timestamp. This method will // also return true if we don't have an active channel announcement for // the target node. IsStaleNode(node route.Vertex, timestamp time.Time) bool // IsPublicNode determines whether the given vertex is seen as a public // node in the graph from the graph's source node's point of view. IsPublicNode(node route.Vertex) (bool, error) // IsKnownEdge returns true if the graph source already knows of the // passed channel ID either as a live or zombie edge. IsKnownEdge(chanID lnwire.ShortChannelID) bool // IsStaleEdgePolicy returns true if the graph source has a channel // edge for the passed channel ID (and flags) that have a more recent // timestamp. IsStaleEdgePolicy(chanID lnwire.ShortChannelID, timestamp time.Time, flags lnwire.ChanUpdateChanFlags) bool // MarkEdgeLive clears an edge from our zombie index, deeming it as // live. MarkEdgeLive(chanID lnwire.ShortChannelID) error // ForAllOutgoingChannels is used to iterate over all channels // emanating from the "source" node which is the center of the // star-graph. ForAllOutgoingChannels(cb func(tx kvdb.RTx, c *channeldb.ChannelEdgeInfo, e *channeldb.ChannelEdgePolicy) error) error // CurrentBlockHeight returns the block height from POV of the router // subsystem. CurrentBlockHeight() (uint32, error) // GetChannelByID return the channel by the channel id. GetChannelByID(chanID lnwire.ShortChannelID) (*channeldb.ChannelEdgeInfo, *channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy, error) // FetchLightningNode attempts to look up a target node by its identity // public key. channeldb.ErrGraphNodeNotFound is returned if the node // doesn't exist within the graph. FetchLightningNode(route.Vertex) (*channeldb.LightningNode, error) // ForEachNode is used to iterate over every node in the known graph. ForEachNode(func(node *channeldb.LightningNode) error) error }
ChannelGraphSource represents the source of information about the topology of the lightning network. It's responsible for the addition of nodes, edges, applying edge updates, and returning the current block height with which the topology is synchronized.
type ChannelPolicy ¶
type ChannelPolicy struct { // FeeSchema holds the fee configuration for a channel. FeeSchema // TimeLockDelta is the required HTLC timelock delta to be used // when forwarding payments. TimeLockDelta uint32 // MaxHTLC is the maximum HTLC size including fees we are allowed to // forward over this channel. MaxHTLC lnwire.MilliSatoshi // MinHTLC is the minimum HTLC size including fees we are allowed to // forward over this channel. MinHTLC *lnwire.MilliSatoshi }
ChannelPolicy holds the parameters that determine the policy we enforce when forwarding payments on a channel. These parameters are communicated to the rest of the network in ChannelUpdate messages.
type ChannelRouter ¶
type ChannelRouter struct {
// contains filtered or unexported fields
}
ChannelRouter is the layer 3 router within the Lightning stack. Below the ChannelRouter is the HtlcSwitch, and below that is the Bitcoin blockchain itself. The primary role of the ChannelRouter is to respond to queries for potential routes that can support a payment amount, and also general graph reachability questions. The router will prune the channel graph automatically as new blocks are discovered which spend certain known funding outpoints, thereby closing their respective channels.
func New ¶
func New(cfg Config) (*ChannelRouter, error)
New creates a new instance of the ChannelRouter with the specified configuration parameters. As part of initialization, if the router detects that the channel graph isn't fully in sync with the latest UTXO (since the channel graph is a subset of the UTXO set) set, then the router will proceed to fully sync to the latest state of the UTXO set.
func (*ChannelRouter) AddEdge ¶
func (r *ChannelRouter) AddEdge(edge *channeldb.ChannelEdgeInfo, op ...batch.SchedulerOption) error
AddEdge is used to add edge/channel to the topology of the router, after all information about channel will be gathered this edge/channel might be used in construction of payment path.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) AddNode ¶
func (r *ChannelRouter) AddNode(node *channeldb.LightningNode, op ...batch.SchedulerOption) error
AddNode is used to add information about a node to the router database. If the node with this pubkey is not present in an existing channel, it will be ignored.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) AddProof ¶
func (r *ChannelRouter) AddProof(chanID lnwire.ShortChannelID, proof *channeldb.ChannelAuthProof) error
AddProof updates the channel edge info with proof which is needed to properly announce the edge to the rest of the network.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) BuildRoute ¶
func (r *ChannelRouter) BuildRoute(amt *lnwire.MilliSatoshi, hops []route.Vertex, outgoingChan *uint64, finalCltvDelta int32, payAddr *[32]byte) (*route.Route, error)
BuildRoute returns a fully specified route based on a list of pubkeys. If amount is nil, the minimum routable amount is used. To force a specific outgoing channel, use the outgoingChan parameter.
func (*ChannelRouter) CurrentBlockHeight ¶
func (r *ChannelRouter) CurrentBlockHeight() (uint32, error)
CurrentBlockHeight returns the block height from POV of the router subsystem.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) FetchLightningNode ¶
func (r *ChannelRouter) FetchLightningNode( node route.Vertex) (*channeldb.LightningNode, error)
FetchLightningNode attempts to look up a target node by its identity public key. channeldb.ErrGraphNodeNotFound is returned if the node doesn't exist within the graph.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) FindRoute ¶
func (r *ChannelRouter) FindRoute(source, target route.Vertex, amt lnwire.MilliSatoshi, timePref float64, restrictions *RestrictParams, destCustomRecords record.CustomSet, routeHints map[route.Vertex][]*channeldb.CachedEdgePolicy, finalExpiry uint16) (*route.Route, float64, error)
FindRoute attempts to query the ChannelRouter for the optimum path to a particular target destination to which it is able to send `amt` after factoring in channel capacities and cumulative fees along the route.
func (*ChannelRouter) ForAllOutgoingChannels ¶
func (r *ChannelRouter) ForAllOutgoingChannels(cb func(kvdb.RTx, *channeldb.ChannelEdgeInfo, *channeldb.ChannelEdgePolicy) error) error
ForAllOutgoingChannels is used to iterate over all outgoing channels owned by the router.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) ForEachNode ¶
func (r *ChannelRouter) ForEachNode(cb func(*channeldb.LightningNode) error) error
ForEachNode is used to iterate over every node in router topology.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) GetChannelByID ¶
func (r *ChannelRouter) GetChannelByID(chanID lnwire.ShortChannelID) ( *channeldb.ChannelEdgeInfo, *channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy, error)
GetChannelByID return the channel by the channel id.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) IsKnownEdge ¶
func (r *ChannelRouter) IsKnownEdge(chanID lnwire.ShortChannelID) bool
IsKnownEdge returns true if the graph source already knows of the passed channel ID either as a live or zombie edge.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) IsPublicNode ¶
func (r *ChannelRouter) IsPublicNode(node route.Vertex) (bool, error)
IsPublicNode determines whether the given vertex is seen as a public node in the graph from the graph's source node's point of view.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) IsStaleEdgePolicy ¶
func (r *ChannelRouter) IsStaleEdgePolicy(chanID lnwire.ShortChannelID, timestamp time.Time, flags lnwire.ChanUpdateChanFlags) bool
IsStaleEdgePolicy returns true if the graph source has a channel edge for the passed channel ID (and flags) that have a more recent timestamp.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) IsStaleNode ¶
IsStaleNode returns true if the graph source has a node announcement for the target node with a more recent timestamp.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) MarkEdgeLive ¶
func (r *ChannelRouter) MarkEdgeLive(chanID lnwire.ShortChannelID) error
MarkEdgeLive clears an edge from our zombie index, deeming it as live.
NOTE: This method is part of the ChannelGraphSource interface.
func (*ChannelRouter) SendPayment ¶
func (r *ChannelRouter) SendPayment(payment *LightningPayment) ([32]byte, *route.Route, error)
SendPayment attempts to send a payment as described within the passed LightningPayment. This function is blocking and will return either: when the payment is successful, or all candidates routes have been attempted and resulted in a failed payment. If the payment succeeds, then a non-nil Route will be returned which describes the path the successful payment traversed within the network to reach the destination. Additionally, the payment preimage will also be returned.
func (*ChannelRouter) SendPaymentAsync ¶
func (r *ChannelRouter) SendPaymentAsync(payment *LightningPayment) error
SendPaymentAsync is the non-blocking version of SendPayment. The payment result needs to be retrieved via the control tower.
func (*ChannelRouter) SendToRoute ¶
func (r *ChannelRouter) SendToRoute(htlcHash lntypes.Hash, rt *route.Route) (*channeldb.HTLCAttempt, error)
SendToRoute sends a payment using the provided route and fails the payment when an error is returned from the attempt.
func (*ChannelRouter) SendToRouteSkipTempErr ¶
func (r *ChannelRouter) SendToRouteSkipTempErr(htlcHash lntypes.Hash, rt *route.Route) (*channeldb.HTLCAttempt, error)
SendToRouteSkipTempErr sends a payment using the provided route and fails the payment ONLY when a terminal error is returned from the attempt.
func (*ChannelRouter) Start ¶
func (r *ChannelRouter) Start() error
Start launches all the goroutines the ChannelRouter requires to carry out its duties. If the router has already been started, then this method is a noop.
func (*ChannelRouter) Stop ¶
func (r *ChannelRouter) Stop() error
Stop signals the ChannelRouter to gracefully halt all routines. This method will *block* until all goroutines have excited. If the channel router has already stopped then this method will return immediately.
func (*ChannelRouter) SubscribeTopology ¶
func (r *ChannelRouter) SubscribeTopology() (*TopologyClient, error)
SubscribeTopology returns a new topology client which can be used by the caller to receive notifications whenever a change in the channel graph topology occurs. Changes that will be sent at notifications include: new nodes appearing, node updating their attributes, new channels, channels closing, and updates in the routing policies of a channel's directed edges.
func (*ChannelRouter) SyncedHeight ¶
func (r *ChannelRouter) SyncedHeight() uint32
SyncedHeight returns the block height to which the router subsystem currently is synced to. This can differ from the above chain height if the goroutine responsible for processing the blocks isn't yet up to speed.
func (*ChannelRouter) UpdateEdge ¶
func (r *ChannelRouter) UpdateEdge(update *channeldb.ChannelEdgePolicy, op ...batch.SchedulerOption) error
UpdateEdge is used to update edge information, without this message edge considered as not fully constructed.
NOTE: This method is part of the ChannelGraphSource interface.
type ClosedChanSummary ¶
type ClosedChanSummary struct { // ChanID is the short-channel ID which uniquely identifies the // channel. ChanID uint64 // Capacity was the total capacity of the channel before it was closed. Capacity btcutil.Amount // ClosedHeight is the height in the chain that the channel was closed // at. ClosedHeight uint32 // ChanPoint is the funding point, or the multi-sig utxo which // previously represented the channel. ChanPoint wire.OutPoint }
ClosedChanSummary is a summary of a channel that was detected as being closed by monitoring the blockchain. Once a channel's funding point has been spent, the channel will automatically be marked as closed by the ChainNotifier.
TODO(roasbeef): add nodes involved?
type Config ¶
type Config struct { // Graph is the channel graph that the ChannelRouter will use to gather // metrics from and also to carry out path finding queries. // TODO(roasbeef): make into an interface Graph *channeldb.ChannelGraph // Chain is the router's source to the most up-to-date blockchain data. // All incoming advertised channels will be checked against the chain // to ensure that the channels advertised are still open. Chain lnwallet.BlockChainIO // ChainView is an instance of a FilteredChainView which is used to // watch the sub-set of the UTXO set (the set of active channels) that // we need in order to properly maintain the channel graph. ChainView chainview.FilteredChainView // Notifier is a reference to the ChainNotifier, used to grab // the latest blocks if the router is missing any. Notifier chainntnfs.ChainNotifier // Payer is an instance of a PaymentAttemptDispatcher and is used by // the router to send payment attempts onto the network, and receive // their results. Payer PaymentAttemptDispatcher // Control keeps track of the status of ongoing payments, ensuring we // can properly resume them across restarts. Control ControlTower // MissionControl is a shared memory of sorts that executions of // payment path finding use in order to remember which vertexes/edges // were pruned from prior attempts. During SendPayment execution, // errors sent by nodes are mapped into a vertex or edge to be pruned. // Each run will then take into account this set of pruned // vertexes/edges to reduce route failure and pass on graph information // gained to the next execution. MissionControl MissionController // SessionSource defines a source for the router to retrieve new payment // sessions. SessionSource PaymentSessionSource // ChannelPruneExpiry is the duration used to determine if a channel // should be pruned or not. If the delta between now and when the // channel was last updated is greater than ChannelPruneExpiry, then // the channel is marked as a zombie channel eligible for pruning. ChannelPruneExpiry time.Duration // GraphPruneInterval is used as an interval to determine how often we // should examine the channel graph to garbage collect zombie channels. GraphPruneInterval time.Duration // FirstTimePruneDelay is the time we'll wait after startup before // attempting to prune the graph for zombie channels. We don't do it // immediately after startup to allow lnd to start up without getting // blocked by this job. FirstTimePruneDelay time.Duration // QueryBandwidth is a method that allows the router to query the lower // link layer to determine the up to date available bandwidth at a // prospective link to be traversed. If the link isn't available, then // a value of zero should be returned. Otherwise, the current up to // date knowledge of the available bandwidth of the link should be // returned. GetLink getLinkQuery // NextPaymentID is a method that guarantees to return a new, unique ID // each time it is called. This is used by the router to generate a // unique payment ID for each payment it attempts to send, such that // the switch can properly handle the HTLC. NextPaymentID func() (uint64, error) // AssumeChannelValid toggles whether or not the router will check for // spentness of channel outpoints. For neutrino, this saves long rescans // from blocking initial usage of the daemon. AssumeChannelValid bool // PathFindingConfig defines global path finding parameters. PathFindingConfig PathFindingConfig // Clock is mockable time provider. Clock clock.Clock // StrictZombiePruning determines if we attempt to prune zombie // channels according to a stricter criteria. If true, then we'll prune // a channel if only *one* of the edges is considered a zombie. // Otherwise, we'll only prune the channel when both edges have a very // dated last update. StrictZombiePruning bool // IsAlias returns whether a passed ShortChannelID is an alias. This is // only used for our local channels. IsAlias func(scid lnwire.ShortChannelID) bool }
Config defines the configuration for the ChannelRouter. ALL elements within the configuration MUST be non-nil for the ChannelRouter to carry out its duties.
type ControlTower ¶
type ControlTower interface { // This method checks that no succeeded payment exist for this payment // hash. InitPayment(lntypes.Hash, *channeldb.PaymentCreationInfo) error // DeleteFailedAttempts removes all failed HTLCs from the db. It should // be called for a given payment whenever all inflight htlcs are // completed, and the payment has reached a final settled state. DeleteFailedAttempts(lntypes.Hash) error // RegisterAttempt atomically records the provided HTLCAttemptInfo. RegisterAttempt(lntypes.Hash, *channeldb.HTLCAttemptInfo) error // SettleAttempt marks the given attempt settled with the preimage. If // this is a multi shard payment, this might implicitly mean the the // full payment succeeded. // // After invoking this method, InitPayment should always return an // error to prevent us from making duplicate payments to the same // payment hash. The provided preimage is atomically saved to the DB // for record keeping. SettleAttempt(lntypes.Hash, uint64, *channeldb.HTLCSettleInfo) ( *channeldb.HTLCAttempt, error) // FailAttempt marks the given payment attempt failed. FailAttempt(lntypes.Hash, uint64, *channeldb.HTLCFailInfo) ( *channeldb.HTLCAttempt, error) // FetchPayment fetches the payment corresponding to the given payment // hash. FetchPayment(paymentHash lntypes.Hash) (*channeldb.MPPayment, error) // FailPayment transitions a payment into the Failed state, and records // the ultimate reason the payment failed. Note that this should only // be called when all active attempts are already failed. After // invoking this method, InitPayment should return nil on its next call // for this payment hash, allowing the user to make a subsequent // payment. FailPayment(lntypes.Hash, channeldb.FailureReason) error // FetchInFlightPayments returns all payments with status InFlight. FetchInFlightPayments() ([]*channeldb.MPPayment, error) // SubscribePayment subscribes to updates for the payment with the given // hash. A first update with the current state of the payment is always // sent out immediately. SubscribePayment(paymentHash lntypes.Hash) (ControlTowerSubscriber, error) // SubscribeAllPayments subscribes to updates for all payments. A first // update with the current state of every inflight payment is always // sent out immediately. SubscribeAllPayments() (ControlTowerSubscriber, error) }
ControlTower tracks all outgoing payments made, whose primary purpose is to prevent duplicate payments to the same payment hash. In production, a persistent implementation is preferred so that tracking can survive across restarts. Payments are transitioned through various payment states, and the ControlTower interface provides access to driving the state transitions.
func NewControlTower ¶
func NewControlTower(db *channeldb.PaymentControl) ControlTower
NewControlTower creates a new instance of the controlTower.
type ControlTowerSubscriber ¶
type ControlTowerSubscriber interface { // Updates is the channel over which *channeldb.MPPayment updates can be // received. Updates() <-chan interface{} // Close signals that the subscriber is no longer interested in updates. Close() }
ControlTowerSubscriber contains the state for a payment update subscriber.
type DirectedNodePair ¶
DirectedNodePair stores a directed pair of nodes.
func NewDirectedNodePair ¶
func NewDirectedNodePair(from, to route.Vertex) DirectedNodePair
NewDirectedNodePair instantiates a new DirectedNodePair struct.
func (DirectedNodePair) Reverse ¶
func (d DirectedNodePair) Reverse() DirectedNodePair
Reverse returns a reversed copy of the pair.
func (DirectedNodePair) String ¶
func (d DirectedNodePair) String() string
String converts a node pair to its human readable representation.
type EdgeLocator ¶
type EdgeLocator struct { // ChannelID is the channel of this edge. ChannelID uint64 // Direction takes the value of 0 or 1 and is identical in definition to // the channel direction flag. A value of 0 means the direction from the // lower node pubkey to the higher. Direction uint8 }
EdgeLocator is a struct used to identify a specific edge.
func (*EdgeLocator) String ¶
func (e *EdgeLocator) String() string
String returns a human readable version of the edgeLocator values.
type ErrNoChannel ¶
type ErrNoChannel struct {
// contains filtered or unexported fields
}
ErrNoChannel is returned when a route cannot be built because there are no channels that satisfy all requirements.
func (ErrNoChannel) Error ¶
func (e ErrNoChannel) Error() string
Error returns a human readable string describing the error.
type Estimator ¶
type Estimator interface { // PairProbability estimates the probability of successfully traversing // to toNode based on historical payment outcomes for the from node. // Those outcomes are passed in via the results parameter. PairProbability(now time.Time, results NodeResults, toNode route.Vertex, amt lnwire.MilliSatoshi, capacity btcutil.Amount) float64 // LocalPairProbability estimates the probability of successfully // traversing our own local channels to toNode. LocalPairProbability(now time.Time, results NodeResults, toNode route.Vertex) float64 // Config returns the estimator's configuration. Config() estimatorConfig // String returns the string representation of the estimator's // configuration. String() string }
Estimator estimates the probability to reach a node.
type FeeSchema ¶
type FeeSchema struct { // BaseFee is the base amount of milli-satoshis that will be chained // for ANY payment forwarded. BaseFee lnwire.MilliSatoshi // FeeRate is the rate that will be charged for forwarding payments. // This value should be interpreted as the numerator for a fraction // (fixed point arithmetic) whose denominator is 1 million. As a result // the effective fee rate charged per mSAT will be: (amount * // FeeRate/1,000,000). FeeRate uint32 }
FeeSchema is the set fee configuration for a Lightning Node on the network. Using the coefficients described within the schema, the required fee to forward outgoing payments can be derived.
type LightningPayment ¶
type LightningPayment struct { // Target is the node in which the payment should be routed towards. Target route.Vertex // Amount is the value of the payment to send through the network in // milli-satoshis. Amount lnwire.MilliSatoshi // FeeLimit is the maximum fee in millisatoshis that the payment should // accept when sending it through the network. The payment will fail // if there isn't a route with lower fees than this limit. FeeLimit lnwire.MilliSatoshi // CltvLimit is the maximum time lock that is allowed for attempts to // complete this payment. CltvLimit uint32 // FinalCLTVDelta is the CTLV expiry delta to use for the _final_ hop // in the route. This means that the final hop will have a CLTV delta // of at least: currentHeight + FinalCLTVDelta. FinalCLTVDelta uint16 // PayAttemptTimeout is a timeout value that we'll use to determine // when we should should abandon the payment attempt after consecutive // payment failure. This prevents us from attempting to send a payment // indefinitely. A zero value means the payment will never time out. // // TODO(halseth): make wallclock time to allow resume after startup. PayAttemptTimeout time.Duration // RouteHints represents the different routing hints that can be used to // assist a payment in reaching its destination successfully. These // hints will act as intermediate hops along the route. // // NOTE: This is optional unless required by the payment. When providing // multiple routes, ensure the hop hints within each route are chained // together and sorted in forward order in order to reach the // destination successfully. RouteHints [][]zpay32.HopHint // OutgoingChannelIDs is the list of channels that are allowed for the // first hop. If nil, any channel may be used. OutgoingChannelIDs []uint64 // LastHop is the pubkey of the last node before the final destination // is reached. If nil, any node may be used. LastHop *route.Vertex // DestFeatures specifies the set of features we assume the final node // has for pathfinding. Typically these will be taken directly from an // invoice, but they can also be manually supplied or assumed by the // sender. If a nil feature vector is provided, the router will try to // fallback to the graph in order to load a feature vector for a node in // the public graph. DestFeatures *lnwire.FeatureVector // PaymentAddr is the payment address specified by the receiver. This // field should be a random 32-byte nonce presented in the receiver's // invoice to prevent probing of the destination. PaymentAddr *[32]byte // PaymentRequest is an optional payment request that this payment is // attempting to complete. PaymentRequest []byte // DestCustomRecords are TLV records that are to be sent to the final // hop in the new onion payload format. If the destination does not // understand this new onion payload format, then the payment will // fail. DestCustomRecords record.CustomSet // MaxParts is the maximum number of partial payments that may be used // to complete the full amount. MaxParts uint32 // MaxShardAmt is the largest shard that we'll attempt to split using. // If this field is set, and we need to split, rather than attempting // half of the original payment amount, we'll use this value if half // the payment amount is greater than it. // // NOTE: This field is _optional_. MaxShardAmt *lnwire.MilliSatoshi // TimePref is the time preference for this payment. Set to -1 to // optimize for fees only, to 1 to optimize for reliability only or a // value in between for a mix. TimePref float64 // Metadata is additional data that is sent along with the payment to // the payee. Metadata []byte // contains filtered or unexported fields }
LightningPayment describes a payment to be sent through the network to the final destination.
func (*LightningPayment) Identifier ¶
func (l *LightningPayment) Identifier() [32]byte
Identifier returns a 32-byte slice that uniquely identifies this single payment. For non-AMP payments this will be the payment hash, for AMP payments this will be the used SetID.
func (*LightningPayment) SetAMP ¶
func (l *LightningPayment) SetAMP(amp *AMPOptions) error
SetAMP sets the given AMP options for the payment.
func (*LightningPayment) SetPaymentHash ¶
func (l *LightningPayment) SetPaymentHash(hash lntypes.Hash) error
SetPaymentHash sets the given hash as the payment's overall hash. This should only be used for non-AMP payments.
type MissionControl ¶
MissionControl contains state which summarizes the past attempts of HTLC routing by external callers when sending payments throughout the network. It acts as a shared memory during routing attempts with the goal to optimize the payment attempt success rate.
Failed payment attempts are reported to mission control. These reports are used to track the time of the last node or channel level failure. The time since the last failure is used to estimate a success probability that is fed into the path finding process for subsequent payment attempts.
func NewMissionControl ¶
func NewMissionControl(db kvdb.Backend, self route.Vertex, cfg *MissionControlConfig) (*MissionControl, error)
NewMissionControl returns a new instance of missionControl.
func (*MissionControl) GetConfig ¶
func (m *MissionControl) GetConfig() *MissionControlConfig
GetConfig returns the config that mission control is currently configured with. All fields are copied by value, so we do not need to worry about mutation.
func (*MissionControl) GetHistorySnapshot ¶
func (m *MissionControl) GetHistorySnapshot() *MissionControlSnapshot
GetHistorySnapshot takes a snapshot from the current mission control state and actual probability estimates.
func (*MissionControl) GetPairHistorySnapshot ¶
func (m *MissionControl) GetPairHistorySnapshot( fromNode, toNode route.Vertex) TimedPairResult
GetPairHistorySnapshot returns the stored history for a given node pair.
func (*MissionControl) GetProbability ¶
func (m *MissionControl) GetProbability(fromNode, toNode route.Vertex, amt lnwire.MilliSatoshi, capacity btcutil.Amount) float64
GetProbability is expected to return the success probability of a payment from fromNode along edge.
func (*MissionControl) ImportHistory ¶
func (m *MissionControl) ImportHistory(history *MissionControlSnapshot, force bool) error
ImportHistory imports the set of mission control results provided to our in-memory state. These results are not persisted, so will not survive restarts.
func (*MissionControl) ReportPaymentFail ¶
func (m *MissionControl) ReportPaymentFail(paymentID uint64, rt *route.Route, failureSourceIdx *int, failure lnwire.FailureMessage) ( *channeldb.FailureReason, error)
ReportPaymentFail reports a failed payment to mission control as input for future probability estimates. The failureSourceIdx argument indicates the failure source. If it is nil, the failure source is unknown. This function returns a reason if this failure is a final failure. In that case no further payment attempts need to be made.
func (*MissionControl) ReportPaymentSuccess ¶
func (m *MissionControl) ReportPaymentSuccess(paymentID uint64, rt *route.Route) error
ReportPaymentSuccess reports a successful payment to mission control as input for future probability estimates.
func (*MissionControl) ResetHistory ¶
func (m *MissionControl) ResetHistory() error
ResetHistory resets the history of MissionControl returning it to a state as if no payment attempts have been made.
func (*MissionControl) RunStoreTicker ¶
func (m *MissionControl) RunStoreTicker()
RunStoreTicker runs the mission control store's ticker.
func (*MissionControl) SetConfig ¶
func (m *MissionControl) SetConfig(cfg *MissionControlConfig) error
SetConfig validates the config provided and updates mission control's config if it is valid.
func (*MissionControl) StopStoreTicker ¶
func (m *MissionControl) StopStoreTicker()
StopStoreTicker stops the mission control store's ticker.
type MissionControlConfig ¶
type MissionControlConfig struct { // Estimator gives probability estimates for node pairs. Estimator Estimator // MaxMcHistory defines the maximum number of payment results that are // held on disk. MaxMcHistory int // McFlushInterval defines the ticker interval when we flush the // accumulated state to the DB. McFlushInterval time.Duration // MinFailureRelaxInterval is the minimum time that must have passed // since the previously recorded failure before the failure amount may // be raised. MinFailureRelaxInterval time.Duration }
MissionControlConfig defines parameters that control mission control behaviour.
func (*MissionControlConfig) String ¶
func (c *MissionControlConfig) String() string
String returns a string representation of a mission control config.
type MissionControlPairSnapshot ¶
type MissionControlPairSnapshot struct { // Pair is the node pair of which the state is described. Pair DirectedNodePair // TimedPairResult contains the data for this pair. TimedPairResult }
MissionControlPairSnapshot contains a snapshot of the current node pair state in mission control.
type MissionControlSnapshot ¶
type MissionControlSnapshot struct { // Pairs is a list of channels for which specific information is // logged. Pairs []MissionControlPairSnapshot }
MissionControlSnapshot contains a snapshot of the current state of mission control.
type MissionController ¶
type MissionController interface { // ReportPaymentFail reports a failed payment to mission control as // input for future probability estimates. It returns a bool indicating // whether this error is a final error and no further payment attempts // need to be made. ReportPaymentFail(attemptID uint64, rt *route.Route, failureSourceIdx *int, failure lnwire.FailureMessage) ( *channeldb.FailureReason, error) // ReportPaymentSuccess reports a successful payment to mission control as input // for future probability estimates. ReportPaymentSuccess(attemptID uint64, rt *route.Route) error // GetProbability is expected to return the success probability of a // payment from fromNode along edge. GetProbability(fromNode, toNode route.Vertex, amt lnwire.MilliSatoshi, capacity btcutil.Amount) float64 }
MissionController is an interface that exposes failure reporting and probability estimation.
type NetworkNodeUpdate ¶
type NetworkNodeUpdate struct { // Addresses is a slice of all the node's known addresses. Addresses []net.Addr // IdentityKey is the identity public key of the target node. This is // used to encrypt onion blobs as well as to authenticate any new // updates. IdentityKey *btcec.PublicKey // Alias is the alias or nick name of the node. Alias string // Color is the node's color in hex code format. Color string // Features holds the set of features the node supports. Features *lnwire.FeatureVector }
NetworkNodeUpdate is an update for a node within the Lightning Network. A NetworkNodeUpdate is sent out either when a new node joins the network, or a node broadcasts a new update with a newer time stamp that supersedes its old update. All updates are properly authenticated.
type NodeResults ¶
type NodeResults map[route.Vertex]TimedPairResult
NodeResults contains previous results from a node to its peers.
type PathFindingConfig ¶
type PathFindingConfig struct { // AttemptCost is the fixed virtual cost in path finding of a failed // payment attempt. It is used to trade off potentially better routes // against their probability of succeeding. AttemptCost lnwire.MilliSatoshi // AttemptCostPPM is the proportional virtual cost in path finding of a // failed payment attempt. It is used to trade off potentially better // routes against their probability of succeeding. This parameter is // expressed in parts per million of the total payment amount. AttemptCostPPM int64 // MinProbability defines the minimum success probability of the // returned route. MinProbability float64 }
PathFindingConfig defines global parameters that control the trade-off in path finding between fees and probabiity.
type PaymentAttemptDispatcher ¶
type PaymentAttemptDispatcher interface { // SendHTLC is a function that directs a link-layer switch to // forward a fully encoded payment to the first hop in the route // denoted by its public key. A non-nil error is to be returned if the // payment was unsuccessful. SendHTLC(firstHop lnwire.ShortChannelID, attemptID uint64, htlcAdd *lnwire.UpdateAddHTLC) error // GetAttemptResult returns the result of the payment attempt with // the given attemptID. The paymentHash should be set to the payment's // overall hash, or in case of AMP payments the payment's unique // identifier. // // The method returns a channel where the payment result will be sent // when available, or an error is encountered during forwarding. When a // result is received on the channel, the HTLC is guaranteed to no // longer be in flight. The switch shutting down is signaled by // closing the channel. If the attemptID is unknown, // ErrPaymentIDNotFound will be returned. GetAttemptResult(attemptID uint64, paymentHash lntypes.Hash, deobfuscator htlcswitch.ErrorDecrypter) ( <-chan *htlcswitch.PaymentResult, error) // CleanStore calls the underlying result store, telling it is safe to // delete all entries except the ones in the keepPids map. This should // be called periodically to let the switch clean up payment results // that we have handled. // NOTE: New payment attempts MUST NOT be made after the keepPids map // has been created and this method has returned. CleanStore(keepPids map[uint64]struct{}) error }
PaymentAttemptDispatcher is used by the router to send payment attempts onto the network, and receive their results.
type PaymentSession ¶
type PaymentSession interface { // RequestRoute returns the next route to attempt for routing the // specified HTLC payment to the target node. The returned route should // carry at most maxAmt to the target node, and pay at most feeLimit in // fees. It can carry less if the payment is MPP. The activeShards // argument should be set to instruct the payment session about the // number of in flight HTLCS for the payment, such that it can choose // splitting strategy accordingly. // // A noRouteError is returned if a non-critical error is encountered // during path finding. RequestRoute(maxAmt, feeLimit lnwire.MilliSatoshi, activeShards, height uint32) (*route.Route, error) // UpdateAdditionalEdge takes an additional channel edge policy // (private channels) and applies the update from the message. Returns // a boolean to indicate whether the update has been applied without // error. UpdateAdditionalEdge(msg *lnwire.ChannelUpdate, pubKey *btcec.PublicKey, policy *channeldb.CachedEdgePolicy) bool // GetAdditionalEdgePolicy uses the public key and channel ID to query // the ephemeral channel edge policy for additional edges. Returns a nil // if nothing found. GetAdditionalEdgePolicy(pubKey *btcec.PublicKey, channelID uint64) *channeldb.CachedEdgePolicy }
PaymentSession is used during SendPayment attempts to provide routes to attempt. It also defines methods to give the PaymentSession additional information learned during the previous attempts.
type PaymentSessionSource ¶
type PaymentSessionSource interface { // NewPaymentSession creates a new payment session that will produce // routes to the given target. An optional set of routing hints can be // provided in order to populate additional edges to explore when // finding a path to the payment's destination. NewPaymentSession(p *LightningPayment) (PaymentSession, error) // NewPaymentSessionEmpty creates a new paymentSession instance that is // empty, and will be exhausted immediately. Used for failure reporting // to missioncontrol for resumed payment we don't want to make more // attempts for. NewPaymentSessionEmpty() PaymentSession }
PaymentSessionSource is an interface that defines a source for the router to retrieve new payment sessions.
type RestrictParams ¶
type RestrictParams struct { // ProbabilitySource is a callback that is expected to return the // success probability of traversing the channel from the node. ProbabilitySource func(route.Vertex, route.Vertex, lnwire.MilliSatoshi, btcutil.Amount) float64 // FeeLimit is a maximum fee amount allowed to be used on the path from // the source to the target. FeeLimit lnwire.MilliSatoshi // OutgoingChannelIDs is the list of channels that are allowed for the // first hop. If nil, any channel may be used. OutgoingChannelIDs []uint64 // LastHop is the pubkey of the last node before the final destination // is reached. If nil, any node may be used. LastHop *route.Vertex // CltvLimit is the maximum time lock of the route excluding the final // ctlv. After path finding is complete, the caller needs to increase // all cltv expiry heights with the required final cltv delta. CltvLimit uint32 // DestCustomRecords contains the custom records to drop off at the // final hop, if any. DestCustomRecords record.CustomSet // DestFeatures is a feature vector describing what the final hop // supports. If none are provided, pathfinding will try to inspect any // features on the node announcement instead. DestFeatures *lnwire.FeatureVector // PaymentAddr is a random 32-byte value generated by the receiver to // mitigate probing vectors and payment sniping attacks on overpaid // invoices. PaymentAddr *[32]byte // Metadata is additional data that is sent along with the payment to // the payee. Metadata []byte }
RestrictParams wraps the set of restrictions passed to findPath that the found path must adhere to.
type SessionSource ¶
type SessionSource struct { // Graph is the channel graph that will be used to gather metrics from // and also to carry out path finding queries. Graph *channeldb.ChannelGraph // SourceNode is the graph's source node. SourceNode *channeldb.LightningNode // GetLink is a method that allows querying the lower link layer // to determine the up to date available bandwidth at a prospective link // to be traversed. If the link isn't available, then a value of zero // should be returned. Otherwise, the current up to date knowledge of // the available bandwidth of the link should be returned. GetLink getLinkQuery // MissionControl is a shared memory of sorts that executions of payment // path finding use in order to remember which vertexes/edges were // pruned from prior attempts. During payment execution, errors sent by // nodes are mapped into a vertex or edge to be pruned. Each run will // then take into account this set of pruned vertexes/edges to reduce // route failure and pass on graph information gained to the next // execution. MissionControl MissionController // PathFindingConfig defines global parameters that control the // trade-off in path finding between fees and probabiity. PathFindingConfig PathFindingConfig }
SessionSource defines a source for the router to retrieve new payment sessions.
func (*SessionSource) NewPaymentSession ¶
func (m *SessionSource) NewPaymentSession(p *LightningPayment) ( PaymentSession, error)
NewPaymentSession creates a new payment session backed by the latest prune view from Mission Control. An optional set of routing hints can be provided in order to populate additional edges to explore when finding a path to the payment's destination.
func (*SessionSource) NewPaymentSessionEmpty ¶
func (m *SessionSource) NewPaymentSessionEmpty() PaymentSession
NewPaymentSessionEmpty creates a new paymentSession instance that is empty, and will be exhausted immediately. Used for failure reporting to missioncontrol for resumed payment we don't want to make more attempts for.
type TimedPairResult ¶
type TimedPairResult struct { // FailTime is the time of the last failure. FailTime time.Time // FailAmt is the amount of the last failure. This amount may be pushed // up if a later success is higher than the last failed amount. FailAmt lnwire.MilliSatoshi // SuccessTime is the time of the last success. SuccessTime time.Time // SuccessAmt is the highest amount that successfully forwarded. This // isn't necessarily the last success amount. The value of this field // may also be pushed down if a later failure is lower than the highest // success amount. Because of this, SuccessAmt may not match // SuccessTime. SuccessAmt lnwire.MilliSatoshi }
TimedPairResult describes a timestamped pair result.
type TopologyChange ¶
type TopologyChange struct { // NodeUpdates is a slice of nodes which are either new to the channel // graph, or have had their attributes updated in an authenticated // manner. NodeUpdates []*NetworkNodeUpdate // ChanelEdgeUpdates is a slice of channel edges which are either newly // opened and authenticated, or have had their routing policies // updated. ChannelEdgeUpdates []*ChannelEdgeUpdate // ClosedChannels contains a slice of close channel summaries which // described which block a channel was closed at, and also carry // supplemental information such as the capacity of the former channel. ClosedChannels []*ClosedChanSummary }
TopologyChange represents a new set of modifications to the channel graph. Topology changes will be dispatched in real-time as the ChannelGraph validates and process modifications to the authenticated channel graph.
type TopologyClient ¶
type TopologyClient struct { // TopologyChanges is a receive only channel that new channel graph // updates will be sent over. // // TODO(roasbeef): chan for each update type instead? TopologyChanges <-chan *TopologyChange // Cancel is a function closure that should be executed when the client // wishes to cancel their notification intent. Doing so allows the // ChannelRouter to free up resources. Cancel func() }
TopologyClient represents an intent to receive notifications from the channel router regarding changes to the topology of the channel graph. The TopologyChanges channel will be sent upon with new updates to the channel graph in real-time as they're encountered.
type ValidationBarrier ¶
ValidationBarrier is a barrier used to ensure proper validation order while concurrently validating new announcements for channel edges, and the attributes of channel edges. It uses this set of maps (protected by this mutex) to track validation dependencies. For a given channel our dependencies look like this: chanAnn <- chanUp <- nodeAnn. That is we must validate the item on the left of the arrow before that on the right.
func NewValidationBarrier ¶
func NewValidationBarrier(numActiveReqs int, quitChan chan struct{}) *ValidationBarrier
NewValidationBarrier creates a new instance of a validation barrier given the total number of active requests, and a quit channel which will be used to know when to kill pending, but unfilled jobs.
func (*ValidationBarrier) CompleteJob ¶
func (v *ValidationBarrier) CompleteJob()
CompleteJob returns a free slot to the set of available job slots. This should be called once a job has been fully completed. Otherwise, slots may not be returned to the internal scheduling, causing a deadlock when a new overflow job is attempted.
func (*ValidationBarrier) InitJobDependencies ¶
func (v *ValidationBarrier) InitJobDependencies(job interface{})
InitJobDependencies will wait for a new job slot to become open, and then sets up any dependent signals/trigger for the new job
func (*ValidationBarrier) SignalDependants ¶
func (v *ValidationBarrier) SignalDependants(job interface{}, allow bool)
SignalDependants will allow/deny any jobs that are dependent on this job that they can continue execution. If the job doesn't have any dependants, then this function sill exit immediately.
func (*ValidationBarrier) WaitForDependants ¶
func (v *ValidationBarrier) WaitForDependants(job interface{}) error
WaitForDependants will block until any jobs that this job dependants on have finished executing. This allows us a graceful way to schedule goroutines based on any pending uncompleted dependent jobs. If this job doesn't have an active dependent, then this function will return immediately.
Source Files
¶
- ann_validation.go
- bandwidth.go
- control_tower.go
- errors.go
- graph.go
- heap.go
- log.go
- missioncontrol.go
- missioncontrol_state.go
- missioncontrol_store.go
- nodepair.go
- notifications.go
- pathfind.go
- payment_lifecycle.go
- payment_session.go
- payment_session_source.go
- probability_apriori.go
- probability_bimodal.go
- probability_estimator.go
- result_interpretation.go
- router.go
- stats.go
- unified_edges.go
- validation_barrier.go