13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.05

/routing/payment_session_source.go

package routing

import (
        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/graph/db/models"
        "github.com/lightningnetwork/lnd/htlcswitch"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/routing/route"
        "github.com/lightningnetwork/lnd/tlv"
        "github.com/lightningnetwork/lnd/zpay32"
)

// A compile time assertion to ensure SessionSource meets the
// PaymentSessionSource interface.
var _ PaymentSessionSource = (*SessionSource)(nil)

// SessionSource defines a source for the router to retrieve new payment
// sessions.
type SessionSource struct {
        // GraphSessionFactory can be used to gain access to a Graph session.
        // If the backing DB allows it, this will mean that a read transaction
        // is being held during the use of the session.
        GraphSessionFactory GraphSessionFactory

        // SourceNode is the graph's source node.
        SourceNode *models.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 MissionControlQuerier

        // PathFindingConfig defines global parameters that control the
        // trade-off in path finding between fees and probability.
        PathFindingConfig PathFindingConfig
}

// 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 (m *SessionSource) NewPaymentSession(p *LightningPayment,
        firstHopBlob fn.Option[tlv.Blob],
        trafficShaper fn.Option[htlcswitch.AuxTrafficShaper]) (PaymentSession,
        error) {

        getBandwidthHints := func(graph Graph) (bandwidthHints, error) {
                return newBandwidthManager(
                        graph, m.SourceNode.PubKeyBytes, m.GetLink,
                        firstHopBlob, trafficShaper,
                )
        }

        session, err := newPaymentSession(
                p, m.SourceNode.PubKeyBytes, getBandwidthHints,
                m.GraphSessionFactory, m.MissionControl, m.PathFindingConfig,
        )
        if err != nil {
                return nil, err
        }

        return session, nil
}

// 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.
func (m *SessionSource) NewPaymentSessionEmpty() PaymentSession {
        return &paymentSession{
                empty: true,
        }
}

// RouteHintsToEdges converts a list of invoice route hints to an edge map that
// can be passed into pathfinding.
func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (
        map[route.Vertex][]AdditionalEdge, error) {

        edges := make(map[route.Vertex][]AdditionalEdge)

        // Traverse through all of the available hop hints and include them in
        // our edges map, indexed by the public key of the channel's starting
        // node.
        for _, routeHint := range routeHints {
                // If multiple hop hints are provided within a single route
                // hint, we'll assume they must be chained together and sorted
                // in forward order in order to reach the target successfully.
                for i, hopHint := range routeHint {
                        // In order to determine the end node of this hint,
                        // we'll need to look at the next hint's start node. If
                        // we've reached the end of the hints list, we can
                        // assume we've reached the destination.
                        endNode := &models.LightningNode{}
                        if i != len(routeHint)-1 {
                                endNode.AddPubKey(routeHint[i+1].NodeID)
                        } else {
                                targetPubKey, err := btcec.ParsePubKey(
                                        target[:],
                                )
                                if err != nil {
                                        return nil, err
                                }
                                endNode.AddPubKey(targetPubKey)
                        }

                        // Finally, create the channel edge from the hop hint
                        // and add it to list of edges corresponding to the node
                        // at the start of the channel.
                        edgePolicy := &models.CachedEdgePolicy{
                                ToNodePubKey: func() route.Vertex {
                                        return endNode.PubKeyBytes
                                },
                                ToNodeFeatures: lnwire.EmptyFeatureVector(),
                                ChannelID:      hopHint.ChannelID,
                                FeeBaseMSat: lnwire.MilliSatoshi(
                                        hopHint.FeeBaseMSat,
                                ),
                                FeeProportionalMillionths: lnwire.MilliSatoshi(
                                        hopHint.FeeProportionalMillionths,
                                ),
                                TimeLockDelta: hopHint.CLTVExpiryDelta,
                        }

                        edge := &PrivateEdge{
                                policy: edgePolicy,
                        }

                        v := route.NewVertex(hopHint.NodeID)
                        edges[v] = append(edges[v], edge)
                }
        }

        return edges, nil
}

1	package routing
2
3	import (
4	"github.com/btcsuite/btcd/btcec/v2"
5	"github.com/lightningnetwork/lnd/fn/v2"
6	"github.com/lightningnetwork/lnd/graph/db/models"
7	"github.com/lightningnetwork/lnd/htlcswitch"
8	"github.com/lightningnetwork/lnd/lnwire"
9	"github.com/lightningnetwork/lnd/routing/route"
10	"github.com/lightningnetwork/lnd/tlv"
11	"github.com/lightningnetwork/lnd/zpay32"
12	)
13
14	// A compile time assertion to ensure SessionSource meets the
15	// PaymentSessionSource interface.
16	var _ PaymentSessionSource = (*SessionSource)(nil)
17
18	// SessionSource defines a source for the router to retrieve new payment
19	// sessions.
20	type SessionSource struct {
21	// GraphSessionFactory can be used to gain access to a Graph session.
22	// If the backing DB allows it, this will mean that a read transaction
23	// is being held during the use of the session.
24	GraphSessionFactory GraphSessionFactory
25
26	// SourceNode is the graph's source node.
27	SourceNode *models.LightningNode
28
29	// GetLink is a method that allows querying the lower link layer
30	// to determine the up to date available bandwidth at a prospective link
31	// to be traversed. If the link isn't available, then a value of zero
32	// should be returned. Otherwise, the current up to date knowledge of
33	// the available bandwidth of the link should be returned.
34	GetLink getLinkQuery
35
36	// MissionControl is a shared memory of sorts that executions of payment
37	// path finding use in order to remember which vertexes/edges were
38	// pruned from prior attempts. During payment execution, errors sent by
39	// nodes are mapped into a vertex or edge to be pruned. Each run will
40	// then take into account this set of pruned vertexes/edges to reduce
41	// route failure and pass on graph information gained to the next
42	// execution.
43	MissionControl MissionControlQuerier
44
45	// PathFindingConfig defines global parameters that control the
46	// trade-off in path finding between fees and probability.
47	PathFindingConfig PathFindingConfig
48	}
49
50	// NewPaymentSession creates a new payment session backed by the latest prune
51	// view from Mission Control. An optional set of routing hints can be provided
52	// in order to populate additional edges to explore when finding a path to the
53	// payment's destination.
54	func (m SessionSource) NewPaymentSession(p LightningPayment,
55	firstHopBlob fn.Option[tlv.Blob],
56	trafficShaper fn.Option[htlcswitch.AuxTrafficShaper]) (PaymentSession,
57	error) {	12✔
58		12✔
59	getBandwidthHints := func(graph Graph) (bandwidthHints, error) {	36✔
60	return newBandwidthManager(	24✔
61	graph, m.SourceNode.PubKeyBytes, m.GetLink,	24✔
62	firstHopBlob, trafficShaper,	24✔
63	)	24✔
64	}	24✔
65
66	session, err := newPaymentSession(	12✔
67	p, m.SourceNode.PubKeyBytes, getBandwidthHints,	12✔
68	m.GraphSessionFactory, m.MissionControl, m.PathFindingConfig,	12✔
69	)	12✔
70	if err != nil {	12✔
71	return nil, err	×
72	}	×
73
74	return session, nil	12✔
75	}
76
77	// NewPaymentSessionEmpty creates a new paymentSession instance that is empty,
78	// and will be exhausted immediately. Used for failure reporting to
79	// missioncontrol for resumed payment we don't want to make more attempts for.
UNCOV 80	func (m *SessionSource) NewPaymentSessionEmpty() PaymentSession {	×
UNCOV 81	return &paymentSession{	×
UNCOV 82	empty: true,	×
UNCOV 83	}	×
UNCOV 84	}	×
85
86	// RouteHintsToEdges converts a list of invoice route hints to an edge map that
87	// can be passed into pathfinding.
88	func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (
89	map[route.Vertex][]AdditionalEdge, error) {	23✔
90		23✔
91	edges := make(map[route.Vertex][]AdditionalEdge)	23✔
92		23✔
93	// Traverse through all of the available hop hints and include them in	23✔
94	// our edges map, indexed by the public key of the channel's starting	23✔
95	// node.	23✔
96	for _, routeHint := range routeHints {	28✔
97	// If multiple hop hints are provided within a single route	5✔
98	// hint, we'll assume they must be chained together and sorted	5✔
99	// in forward order in order to reach the target successfully.	5✔
100	for i, hopHint := range routeHint {	10✔
101	// In order to determine the end node of this hint,	5✔
102	// we'll need to look at the next hint's start node. If	5✔
103	// we've reached the end of the hints list, we can	5✔
104	// assume we've reached the destination.	5✔
105	endNode := &models.LightningNode{}	5✔
106	if i != len(routeHint)-1 {	5✔
107	endNode.AddPubKey(routeHint[i+1].NodeID)	×
108	} else {	5✔
109	targetPubKey, err := btcec.ParsePubKey(	5✔
110	target[:],	5✔
111	)	5✔
112	if err != nil {	5✔
113	return nil, err	×
114	}	×
115	endNode.AddPubKey(targetPubKey)	5✔
116	}
117
118	// Finally, create the channel edge from the hop hint
119	// and add it to list of edges corresponding to the node
120	// at the start of the channel.
121	edgePolicy := &models.CachedEdgePolicy{	5✔
122	ToNodePubKey: func() route.Vertex {	15✔
123	return endNode.PubKeyBytes	10✔
124	},	10✔
125	ToNodeFeatures: lnwire.EmptyFeatureVector(),
126	ChannelID: hopHint.ChannelID,
127	FeeBaseMSat: lnwire.MilliSatoshi(
128	hopHint.FeeBaseMSat,
129	),
130	FeeProportionalMillionths: lnwire.MilliSatoshi(
131	hopHint.FeeProportionalMillionths,
132	),
133	TimeLockDelta: hopHint.CLTVExpiryDelta,
134	}
135
136	edge := &PrivateEdge{	5✔
137	policy: edgePolicy,	5✔
138	}	5✔
139		5✔
140	v := route.NewVertex(hopHint.NodeID)	5✔
141	edges[v] = append(edges[v], edge)	5✔
142	}
143	}
144
145	return edges, nil	23✔
146	}

lightningnetwork / lnd / 13236757158

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous