15736109134

Committed 18 Jun 2025 02:46PM UTC coverage: 58.197% (-10.1%) from 68.248%

Build # 15736109134

Build Type

Pull #9752

github

Committed by

web-flow

Commit Message

Merge d2634a68c into 31c74f20f

Pull Request Pull Request #9752: routerrpc: reject payment to invoice that don't have payment secret or blinded paths

Run Details

6 of 13 new or added lines in 2 files covered. (46.15%)

28331 existing lines in 455 files now uncovered.

97860 of 168153 relevant lines covered (58.2%)

1.81 hits per line

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

20.0

/autopilot/agent_constraints.go

package autopilot

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

// AgentConstraints is an interface the agent will query to determine what
// limits it will need to stay inside when opening channels.
type AgentConstraints interface {
        // ChannelBudget should, given the passed parameters, return whether
        // more channels can be opened while still staying within the set
        // constraints. If the constraints allow us to open more channels, then
        // the first return value will represent the amount of additional funds
        // available towards creating channels. The second return value is the
        // exact *number* of additional channels available.
        ChannelBudget(chans []LocalChannel, balance btcutil.Amount) (
                btcutil.Amount, uint32)

        // MaxPendingOpens returns the maximum number of pending channel
        // establishment goroutines that can be lingering. We cap this value in
        // order to control the level of parallelism caused by the autopilot
        // agent.
        MaxPendingOpens() uint16

        // MinChanSize returns the smallest channel that the autopilot agent
        // should create.
        MinChanSize() btcutil.Amount

        // MaxChanSize returns largest channel that the autopilot agent should
        // create.
        MaxChanSize() btcutil.Amount
}

// agentConstraints is an implementation of the AgentConstraints interface that
// indicate the constraints the autopilot agent must adhere to when opening
// channels.
type agentConstraints struct {
        // minChanSize is the smallest channel that the autopilot agent should
        // create.
        minChanSize btcutil.Amount

        // maxChanSize is the largest channel that the autopilot agent should
        // create.
        maxChanSize btcutil.Amount

        // chanLimit is the maximum number of channels that should be created.
        chanLimit uint16

        // allocation is the percentage of total funds that should be committed
        // to automatic channel establishment.
        allocation float64

        // maxPendingOpens is the maximum number of pending channel
        // establishment goroutines that can be lingering. We cap this value in
        // order to control the level of parallelism caused by the autopilot
        // agent.
        maxPendingOpens uint16
}

// A compile time assertion to ensure agentConstraints satisfies the
// AgentConstraints interface.
var _ AgentConstraints = (*agentConstraints)(nil)

// NewConstraints returns a new AgentConstraints with the given limits.
func NewConstraints(minChanSize, maxChanSize btcutil.Amount, chanLimit,
        maxPendingOpens uint16, allocation float64) AgentConstraints {

        return &agentConstraints{
                minChanSize:     minChanSize,
                maxChanSize:     maxChanSize,
                chanLimit:       chanLimit,
                allocation:      allocation,
                maxPendingOpens: maxPendingOpens,
        }
}

// ChannelBudget should, given the passed parameters, return whether more
// channels can be be opened while still staying within the set constraints.
// If the constraints allow us to open more channels, then the first return
// value will represent the amount of additional funds available towards
// creating channels. The second return value is the exact *number* of
// additional channels available.
//
// Note: part of the AgentConstraints interface.
func (h *agentConstraints) ChannelBudget(channels []LocalChannel,
        funds btcutil.Amount) (btcutil.Amount, uint32) {

        // If we're already over our maximum allowed number of channels, then
        // we'll instruct the controller not to create any more channels.
        if len(channels) >= int(h.chanLimit) {
                return 0, 0
        }

        // The number of additional channels that should be opened is the
        // difference between the channel limit, and the number of channels we
        // already have open.
        numAdditionalChans := uint32(h.chanLimit) - uint32(len(channels))

        // First, we'll tally up the total amount of funds that are currently
        // present within the set of active channels.
        var totalChanAllocation btcutil.Amount
        for _, channel := range channels {
                totalChanAllocation += channel.Balance
        }

        // With this value known, we'll now compute the total amount of fund
        // allocated across regular utxo's and channel utxo's.
        totalFunds := funds + totalChanAllocation

        // Once the total amount has been computed, we then calculate the
        // fraction of funds currently allocated to channels.
        fundsFraction := float64(totalChanAllocation) / float64(totalFunds)

        // If this fraction is below our threshold, then we'll return true, to
        // indicate the controller should call Select to obtain a candidate set
        // of channels to attempt to open.
        needMore := fundsFraction < h.allocation
        if !needMore {
                return 0, 0
        }

        // Now that we know we need more funds, we'll compute the amount of
        // additional funds we should allocate towards channels.
        targetAllocation := btcutil.Amount(float64(totalFunds) * h.allocation)
        fundsAvailable := targetAllocation - totalChanAllocation
        return fundsAvailable, numAdditionalChans
}

// MaxPendingOpens returns the maximum number of pending channel establishment
// goroutines that can be lingering. We cap this value in order to control the
// level of parallelism caused by the autopilot agent.
//
// Note: part of the AgentConstraints interface.
func (h *agentConstraints) MaxPendingOpens() uint16 {
        return h.maxPendingOpens
}

// MinChanSize returns the smallest channel that the autopilot agent should
// create.
//
// Note: part of the AgentConstraints interface.
func (h *agentConstraints) MinChanSize() btcutil.Amount {
        return h.minChanSize
}

// MaxChanSize returns largest channel that the autopilot agent should create.
//
// Note: part of the AgentConstraints interface.
func (h *agentConstraints) MaxChanSize() btcutil.Amount {
        return h.maxChanSize
}

1	package autopilot
2
3	import (
4	"github.com/btcsuite/btcd/btcutil"
5	)
6
7	// AgentConstraints is an interface the agent will query to determine what
8	// limits it will need to stay inside when opening channels.
9	type AgentConstraints interface {
10	// ChannelBudget should, given the passed parameters, return whether
11	// more channels can be opened while still staying within the set
12	// constraints. If the constraints allow us to open more channels, then
13	// the first return value will represent the amount of additional funds
14	// available towards creating channels. The second return value is the
15	// exact number of additional channels available.
16	ChannelBudget(chans []LocalChannel, balance btcutil.Amount) (
17	btcutil.Amount, uint32)
18
19	// MaxPendingOpens returns the maximum number of pending channel
20	// establishment goroutines that can be lingering. We cap this value in
21	// order to control the level of parallelism caused by the autopilot
22	// agent.
23	MaxPendingOpens() uint16
24
25	// MinChanSize returns the smallest channel that the autopilot agent
26	// should create.
27	MinChanSize() btcutil.Amount
28
29	// MaxChanSize returns largest channel that the autopilot agent should
30	// create.
31	MaxChanSize() btcutil.Amount
32	}
33
34	// agentConstraints is an implementation of the AgentConstraints interface that
35	// indicate the constraints the autopilot agent must adhere to when opening
36	// channels.
37	type agentConstraints struct {
38	// minChanSize is the smallest channel that the autopilot agent should
39	// create.
40	minChanSize btcutil.Amount
41
42	// maxChanSize is the largest channel that the autopilot agent should
43	// create.
44	maxChanSize btcutil.Amount
45
46	// chanLimit is the maximum number of channels that should be created.
47	chanLimit uint16
48
49	// allocation is the percentage of total funds that should be committed
50	// to automatic channel establishment.
51	allocation float64
52
53	// maxPendingOpens is the maximum number of pending channel
54	// establishment goroutines that can be lingering. We cap this value in
55	// order to control the level of parallelism caused by the autopilot
56	// agent.
57	maxPendingOpens uint16
58	}
59
60	// A compile time assertion to ensure agentConstraints satisfies the
61	// AgentConstraints interface.
62	var _ AgentConstraints = (*agentConstraints)(nil)
63
64	// NewConstraints returns a new AgentConstraints with the given limits.
65	func NewConstraints(minChanSize, maxChanSize btcutil.Amount, chanLimit,
66	maxPendingOpens uint16, allocation float64) AgentConstraints {	3✔
67		3✔
68	return &agentConstraints{	3✔
69	minChanSize: minChanSize,	3✔
70	maxChanSize: maxChanSize,	3✔
71	chanLimit: chanLimit,	3✔
72	allocation: allocation,	3✔
73	maxPendingOpens: maxPendingOpens,	3✔
74	}	3✔
75	}	3✔
76
77	// ChannelBudget should, given the passed parameters, return whether more
78	// channels can be be opened while still staying within the set constraints.
79	// If the constraints allow us to open more channels, then the first return
80	// value will represent the amount of additional funds available towards
81	// creating channels. The second return value is the exact number of
82	// additional channels available.
83	//
84	// Note: part of the AgentConstraints interface.
85	func (h *agentConstraints) ChannelBudget(channels []LocalChannel,
UNCOV 86	funds btcutil.Amount) (btcutil.Amount, uint32) {	×
UNCOV 87		×
UNCOV 88	// If we're already over our maximum allowed number of channels, then	×
UNCOV 89	// we'll instruct the controller not to create any more channels.	×
UNCOV 90	if len(channels) >= int(h.chanLimit) {	×
UNCOV 91	return 0, 0	×
UNCOV 92	}	×
93
94	// The number of additional channels that should be opened is the
95	// difference between the channel limit, and the number of channels we
96	// already have open.
UNCOV 97	numAdditionalChans := uint32(h.chanLimit) - uint32(len(channels))	×
UNCOV 98		×
UNCOV 99	// First, we'll tally up the total amount of funds that are currently	×
UNCOV 100	// present within the set of active channels.	×
UNCOV 101	var totalChanAllocation btcutil.Amount	×
UNCOV 102	for _, channel := range channels {	×
UNCOV 103	totalChanAllocation += channel.Balance	×
UNCOV 104	}	×
105
106	// With this value known, we'll now compute the total amount of fund
107	// allocated across regular utxo's and channel utxo's.
UNCOV 108	totalFunds := funds + totalChanAllocation	×
UNCOV 109		×
UNCOV 110	// Once the total amount has been computed, we then calculate the	×
UNCOV 111	// fraction of funds currently allocated to channels.	×
UNCOV 112	fundsFraction := float64(totalChanAllocation) / float64(totalFunds)	×
UNCOV 113		×
UNCOV 114	// If this fraction is below our threshold, then we'll return true, to	×
UNCOV 115	// indicate the controller should call Select to obtain a candidate set	×
UNCOV 116	// of channels to attempt to open.	×
UNCOV 117	needMore := fundsFraction < h.allocation	×
UNCOV 118	if !needMore {	×
UNCOV 119	return 0, 0	×
UNCOV 120	}	×
121
122	// Now that we know we need more funds, we'll compute the amount of
123	// additional funds we should allocate towards channels.
UNCOV 124	targetAllocation := btcutil.Amount(float64(totalFunds) * h.allocation)	×
UNCOV 125	fundsAvailable := targetAllocation - totalChanAllocation	×
UNCOV 126	return fundsAvailable, numAdditionalChans	×
127	}
128
129	// MaxPendingOpens returns the maximum number of pending channel establishment
130	// goroutines that can be lingering. We cap this value in order to control the
131	// level of parallelism caused by the autopilot agent.
132	//
133	// Note: part of the AgentConstraints interface.
134	func (h *agentConstraints) MaxPendingOpens() uint16 {	×
135	return h.maxPendingOpens	×
136	}	×
137
138	// MinChanSize returns the smallest channel that the autopilot agent should
139	// create.
140	//
141	// Note: part of the AgentConstraints interface.
142	func (h *agentConstraints) MinChanSize() btcutil.Amount {	×
143	return h.minChanSize	×
144	}	×
145
146	// MaxChanSize returns largest channel that the autopilot agent should create.
147	//
148	// Note: part of the AgentConstraints interface.
149	func (h *agentConstraints) MaxChanSize() btcutil.Amount {	×
150	return h.maxChanSize	×
151	}	×

lightningnetwork / lnd / 15736109134

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