13536249039

Committed 26 Feb 2025 03:42AM UTC coverage: 57.462% (-1.4%) from 58.835%

Build # 13536249039

Build Type

Pull #8453

github

Committed by

Roasbeef

Commit Message

peer: update chooseDeliveryScript to gen script if needed

In this commit, we update `chooseDeliveryScript` to generate a new
script if needed. This allows us to fold in a few other lines that
always followed this function into this expanded function.

The tests have been updated accordingly.

Pull Request Pull Request #8453: [4/4] - multi: integrate new rbf coop close FSM into the existing peer flow

Run Details

275 of 1318 new or added lines in 22 files covered. (20.86%)

19521 existing lines in 257 files now uncovered.

103858 of 180741 relevant lines covered (57.46%)

24750.23 hits per line

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

0.0

/autopilot/combinedattach.go

package autopilot

import (
        "fmt"

        "github.com/btcsuite/btcd/btcutil"
)

// WeightedHeuristic is a tuple that associates a weight to an
// AttachmentHeuristic. This is used to determining a node's final score when
// querying several heuristics for scores.
type WeightedHeuristic struct {
        // Weight is this AttachmentHeuristic's relative weight factor. It
        // should be between 0.0 and 1.0.
        Weight float64

        AttachmentHeuristic
}

// WeightedCombAttachment is an implementation of the AttachmentHeuristic
// interface that combines the scores given by several sub-heuristics into one.
type WeightedCombAttachment struct {
        heuristics []*WeightedHeuristic
}

// NewWeightedCombAttachment creates a new instance of a WeightedCombAttachment.
func NewWeightedCombAttachment(h ...*WeightedHeuristic) (
        *WeightedCombAttachment, error) {

        // The sum of weights given to the sub-heuristics must sum to exactly
        // 1.0.
        var sum float64
        for _, w := range h {
                sum += w.Weight
        }

        if sum != 1.0 {
                return nil, fmt.Errorf("weights MUST sum to 1.0 (was %v)", sum)
        }

        return &WeightedCombAttachment{
                heuristics: h,
        }, nil
}

// A compile time assertion to ensure WeightedCombAttachment meets the
// AttachmentHeuristic and ScoreSettable interfaces.
var _ AttachmentHeuristic = (*WeightedCombAttachment)(nil)
var _ ScoreSettable = (*WeightedCombAttachment)(nil)

// Name returns the name of this heuristic.
//
// NOTE: This is a part of the AttachmentHeuristic interface.
func (c *WeightedCombAttachment) Name() string {
        return "weightedcomb"
}

// NodeScores is a method that given the current channel graph, current set of
// local channels and funds available, scores the given nodes according to the
// preference of opening a channel with them. The returned channel candidates
// maps the NodeID to an attachment directive containing a score and a channel
// size.
//
// The scores is determined by querying the set of sub-heuristics, then
// combining these scores into a final score according to the active
// configuration.
//
// The returned scores will be in the range [0, 1.0], where 0 indicates no
// improvement in connectivity if a channel is opened to this node, while 1.0
// is the maximum possible improvement in connectivity.
//
// NOTE: This is a part of the AttachmentHeuristic interface.
func (c *WeightedCombAttachment) NodeScores(g ChannelGraph, chans []LocalChannel,
        chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
        map[NodeID]*NodeScore, error) {

        // We now query each heuristic to determine the score they give to the
        // nodes for the given channel size.
        var subScores []map[NodeID]*NodeScore
        for _, h := range c.heuristics {
                log.Tracef("Getting scores from sub heuristic %v", h.Name())

                s, err := h.NodeScores(
                        g, chans, chanSize, nodes,
                )
                if err != nil {
                        return nil, fmt.Errorf("unable to get sub score: %w",
                                err)
                }

                subScores = append(subScores, s)
        }

        // We combine the scores given by the sub-heuristics by using the
        // heuristics' given weight factor.
        scores := make(map[NodeID]*NodeScore)
        for nID := range nodes {
                score := &NodeScore{
                        NodeID: nID,
                }

                // Each sub-heuristic should have scored the node, if not it is
                // implicitly given a zero score by that heuristic.
                for i, h := range c.heuristics {
                        sub, ok := subScores[i][nID]
                        if !ok {
                                log.Tracef("No score given to node %x by sub "+
                                        "heuristic %v", nID[:], h.Name())
                                continue
                        }
                        // Use the heuristic's weight factor to determine of
                        // how much weight we should give to this particular
                        // score.
                        subScore := h.Weight * sub.Score
                        log.Tracef("Giving node %x a sub score of %v "+
                                "(%v * %v) from sub heuristic %v", nID[:],
                                subScore, h.Weight, sub.Score, h.Name())

                        score.Score += subScore
                }

                log.Tracef("Node %x got final combined score %v", nID[:],
                        score.Score)

                switch {
                // Instead of adding a node with score 0 to the returned set,
                // we just skip it.
                case score.Score == 0:
                        continue

                // Sanity check the new score.
                case score.Score < 0 || score.Score > 1.0:
                        return nil, fmt.Errorf("invalid node score from "+
                                "combination: %v", score.Score)
                }

                scores[nID] = score
        }

        return scores, nil
}

// SetNodeScores is used to set the internal map from NodeIDs to scores. The
// passed scores must be in the range [0, 1.0]. The fist parameter is the name
// of the targeted heuristic, to allow recursively target specific
// sub-heuristics. The returned boolean indicates whether the targeted
// heuristic was found.
//
// Since this heuristic doesn't keep any internal scores, it will recursively
// apply the scores to its sub-heuristics.
//
// NOTE: This is a part of the ScoreSettable interface.
func (c *WeightedCombAttachment) SetNodeScores(targetHeuristic string,
        newScores map[NodeID]float64) (bool, error) {

        found := false
        for _, h := range c.heuristics {
                // It must be ScoreSettable to be available for external
                // scores.
                s, ok := h.AttachmentHeuristic.(ScoreSettable)
                if !ok {
                        continue
                }

                // Heuristic supports scoring, attempt to set them.
                applied, err := s.SetNodeScores(targetHeuristic, newScores)
                if err != nil {
                        return false, err
                }
                found = found || applied
        }

        return found, nil
}

1	package autopilot
2
3	import (
4	"fmt"
5
6	"github.com/btcsuite/btcd/btcutil"
7	)
8
9	// WeightedHeuristic is a tuple that associates a weight to an
10	// AttachmentHeuristic. This is used to determining a node's final score when
11	// querying several heuristics for scores.
12	type WeightedHeuristic struct {
13	// Weight is this AttachmentHeuristic's relative weight factor. It
14	// should be between 0.0 and 1.0.
15	Weight float64
16
17	AttachmentHeuristic
18	}
19
20	// WeightedCombAttachment is an implementation of the AttachmentHeuristic
21	// interface that combines the scores given by several sub-heuristics into one.
22	type WeightedCombAttachment struct {
23	heuristics []*WeightedHeuristic
24	}
25
26	// NewWeightedCombAttachment creates a new instance of a WeightedCombAttachment.
27	func NewWeightedCombAttachment(h ...*WeightedHeuristic) (
UNCOV 28	*WeightedCombAttachment, error) {	×
UNCOV 29		×
UNCOV 30	// The sum of weights given to the sub-heuristics must sum to exactly	×
UNCOV 31	// 1.0.	×
UNCOV 32	var sum float64	×
UNCOV 33	for _, w := range h {	×
UNCOV 34	sum += w.Weight	×
UNCOV 35	}	×
36
UNCOV 37	if sum != 1.0 {	×
38	return nil, fmt.Errorf("weights MUST sum to 1.0 (was %v)", sum)	×
39	}	×
40
UNCOV 41	return &WeightedCombAttachment{	×
UNCOV 42	heuristics: h,	×
UNCOV 43	}, nil	×
44	}
45
46	// A compile time assertion to ensure WeightedCombAttachment meets the
47	// AttachmentHeuristic and ScoreSettable interfaces.
48	var _ AttachmentHeuristic = (*WeightedCombAttachment)(nil)
49	var _ ScoreSettable = (*WeightedCombAttachment)(nil)
50
51	// Name returns the name of this heuristic.
52	//
53	// NOTE: This is a part of the AttachmentHeuristic interface.
54	func (c *WeightedCombAttachment) Name() string {	×
55	return "weightedcomb"	×
56	}	×
57
58	// NodeScores is a method that given the current channel graph, current set of
59	// local channels and funds available, scores the given nodes according to the
60	// preference of opening a channel with them. The returned channel candidates
61	// maps the NodeID to an attachment directive containing a score and a channel
62	// size.
63	//
64	// The scores is determined by querying the set of sub-heuristics, then
65	// combining these scores into a final score according to the active
66	// configuration.
67	//
68	// The returned scores will be in the range [0, 1.0], where 0 indicates no
69	// improvement in connectivity if a channel is opened to this node, while 1.0
70	// is the maximum possible improvement in connectivity.
71	//
72	// NOTE: This is a part of the AttachmentHeuristic interface.
73	func (c *WeightedCombAttachment) NodeScores(g ChannelGraph, chans []LocalChannel,
74	chanSize btcutil.Amount, nodes map[NodeID]struct{}) (
75	map[NodeID]*NodeScore, error) {	×
76		×
77	// We now query each heuristic to determine the score they give to the	×
78	// nodes for the given channel size.	×
79	var subScores []map[NodeID]*NodeScore	×
80	for _, h := range c.heuristics {	×
81	log.Tracef("Getting scores from sub heuristic %v", h.Name())	×
82		×
83	s, err := h.NodeScores(	×
84	g, chans, chanSize, nodes,	×
85	)	×
86	if err != nil {	×
87	return nil, fmt.Errorf("unable to get sub score: %w",	×
88	err)	×
89	}	×
90
91	subScores = append(subScores, s)	×
92	}
93
94	// We combine the scores given by the sub-heuristics by using the
95	// heuristics' given weight factor.
96	scores := make(map[NodeID]*NodeScore)	×
97	for nID := range nodes {	×
98	score := &NodeScore{	×
99	NodeID: nID,	×
100	}	×
101		×
102	// Each sub-heuristic should have scored the node, if not it is	×
103	// implicitly given a zero score by that heuristic.	×
104	for i, h := range c.heuristics {	×
105	sub, ok := subScores[i][nID]	×
106	if !ok {	×
107	log.Tracef("No score given to node %x by sub "+	×
108	"heuristic %v", nID[:], h.Name())	×
109	continue	×
110	}
111	// Use the heuristic's weight factor to determine of
112	// how much weight we should give to this particular
113	// score.
114	subScore := h.Weight * sub.Score	×
115	log.Tracef("Giving node %x a sub score of %v "+	×
116	"(%v * %v) from sub heuristic %v", nID[:],	×
117	subScore, h.Weight, sub.Score, h.Name())	×
118		×
119	score.Score += subScore	×
120	}
121
122	log.Tracef("Node %x got final combined score %v", nID[:],	×
123	score.Score)	×
124		×
125	switch {	×
126	// Instead of adding a node with score 0 to the returned set,
127	// we just skip it.
128	case score.Score == 0:	×
129	continue	×
130
131	// Sanity check the new score.
132	case score.Score < 0 \|\| score.Score > 1.0:	×
133	return nil, fmt.Errorf("invalid node score from "+	×
134	"combination: %v", score.Score)	×
135	}
136
137	scores[nID] = score	×
138	}
139
140	return scores, nil	×
141	}
142
143	// SetNodeScores is used to set the internal map from NodeIDs to scores. The
144	// passed scores must be in the range [0, 1.0]. The fist parameter is the name
145	// of the targeted heuristic, to allow recursively target specific
146	// sub-heuristics. The returned boolean indicates whether the targeted
147	// heuristic was found.
148	//
149	// Since this heuristic doesn't keep any internal scores, it will recursively
150	// apply the scores to its sub-heuristics.
151	//
152	// NOTE: This is a part of the ScoreSettable interface.
153	func (c *WeightedCombAttachment) SetNodeScores(targetHeuristic string,
154	newScores map[NodeID]float64) (bool, error) {	×
155		×
156	found := false	×
157	for _, h := range c.heuristics {	×
158	// It must be ScoreSettable to be available for external	×
159	// scores.	×
160	s, ok := h.AttachmentHeuristic.(ScoreSettable)	×
161	if !ok {	×
162	continue	×
163	}
164
165	// Heuristic supports scoring, attempt to set them.
166	applied, err := s.SetNodeScores(targetHeuristic, newScores)	×
167	if err != nil {	×
168	return false, err	×
169	}	×
170	found = found \|\| applied	×
171	}
172
173	return found, nil	×
174	}

lightningnetwork / lnd / 13536249039

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