12986279612

Committed 27 Jan 2025 09:51AM UTC coverage: 57.652% (-1.1%) from 58.788%

Build # 12986279612

Build Type

Pull #9447

github

Committed by

yyforyongyu

Commit Message

sweep: rename methods for clarity

We now rename "third party" to "unknown" as the inputs can be spent via
an older sweeping tx, a third party (anchor), or a remote party (pin).
In fee bumper we don't have the info to distinguish the above cases, and
leave them to be further handled by the sweeper as it has more context.

Pull Request Pull Request #9447: sweep: start tracking input spending status in the fee bumper

Run Details

83 of 87 new or added lines in 2 files covered. (95.4%)

19578 existing lines in 256 files now uncovered.

103448 of 179434 relevant lines covered (57.65%)

24884.58 hits per line

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

76.19

/chainntnfs/best_block_view.go

package chainntnfs

import (
        "errors"
        "fmt"
        "sync"
        "sync/atomic"

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

// BestBlockView is an interface that allows the querying of the most
// up-to-date blockchain state with low overhead. Valid implementations of this
// interface must track the latest chain state.
type BestBlockView interface {
        // BestHeight gets the most recent block height known to the view.
        BestHeight() (uint32, error)

        // BestBlockHeader gets the most recent block header known to the view.
        BestBlockHeader() (*wire.BlockHeader, error)
}

// BestBlockTracker is a tiny subsystem that tracks the blockchain tip
// and saves the most recent tip information in memory for querying. It is a
// valid implementation of BestBlockView and additionally includes
// methods for starting and stopping the system.
type BestBlockTracker struct {
        notifier        ChainNotifier
        blockNtfnStream *BlockEpochEvent
        current         atomic.Pointer[BlockEpoch]
        mu              sync.Mutex
        quit            chan struct{}
        wg              sync.WaitGroup
}

// This is a compile time check to ensure that BestBlockTracker implements
// BestBlockView.
var _ BestBlockView = (*BestBlockTracker)(nil)

// NewBestBlockTracker creates a new BestBlockTracker that isn't running yet.
// It will not provide up to date information unless it has been started. The
// ChainNotifier parameter must also be started prior to starting the
// BestBlockTracker.
func NewBestBlockTracker(chainNotifier ChainNotifier) *BestBlockTracker {
        return &BestBlockTracker{
                notifier:        chainNotifier,
                blockNtfnStream: nil,
                quit:            make(chan struct{}),
        }
}

// BestHeight gets the most recent block height known to the
// BestBlockTracker.
func (t *BestBlockTracker) BestHeight() (uint32, error) {
        epoch := t.current.Load()
        if epoch == nil {
                return 0, errors.New("best block height not yet known")
        }

        return uint32(epoch.Height), nil
}

// BestBlockHeader gets the most recent block header known to the
// BestBlockTracker.
func (t *BestBlockTracker) BestBlockHeader() (*wire.BlockHeader, error) {
        epoch := t.current.Load()
        if epoch == nil {
                return nil, errors.New("best block header not yet known")
        }

        return epoch.BlockHeader, nil
}

// updateLoop is a helper that subscribes to the underlying BlockEpochEvent
// stream and updates the internal values to match the new BlockEpochs that
// are discovered.
//
// MUST be run as a goroutine.
func (t *BestBlockTracker) updateLoop() {
        defer t.wg.Done()
        for {
                select {
                case epoch, ok := <-t.blockNtfnStream.Epochs:
                        if !ok {
                                Log.Error("dead epoch stream in " +
                                        "BestBlockTracker")

                                return
                        }
                        t.current.Store(epoch)
                case <-t.quit:
                        t.current.Store(nil)
                        return
                }
        }
}

// Start starts the BestBlockTracker. It is an error to start it if it
// is already started.
func (t *BestBlockTracker) Start() error {
        t.mu.Lock()
        defer t.mu.Unlock()

        if t.blockNtfnStream != nil {
                return fmt.Errorf("BestBlockTracker is already started")
        }

        var err error
        t.blockNtfnStream, err = t.notifier.RegisterBlockEpochNtfn(nil)
        if err != nil {
                return err
        }

        t.wg.Add(1)
        go t.updateLoop()

        return nil
}

// Stop stops the BestBlockTracker. It is an error to stop it if it has
// not been started or if it has already been stopped.
func (t *BestBlockTracker) Stop() error {
        t.mu.Lock()
        defer t.mu.Unlock()

        if t.blockNtfnStream == nil {
                return fmt.Errorf("BestBlockTracker is not running")
        }
        close(t.quit)
        t.wg.Wait()
        t.blockNtfnStream.Cancel()
        t.blockNtfnStream = nil

        return nil
}

1	package chainntnfs
2
3	import (
4	"errors"
5	"fmt"
6	"sync"
7	"sync/atomic"
8
9	"github.com/btcsuite/btcd/wire"
10	)
11
12	// BestBlockView is an interface that allows the querying of the most
13	// up-to-date blockchain state with low overhead. Valid implementations of this
14	// interface must track the latest chain state.
15	type BestBlockView interface {
16	// BestHeight gets the most recent block height known to the view.
17	BestHeight() (uint32, error)
18
19	// BestBlockHeader gets the most recent block header known to the view.
20	BestBlockHeader() (*wire.BlockHeader, error)
21	}
22
23	// BestBlockTracker is a tiny subsystem that tracks the blockchain tip
24	// and saves the most recent tip information in memory for querying. It is a
25	// valid implementation of BestBlockView and additionally includes
26	// methods for starting and stopping the system.
27	type BestBlockTracker struct {
28	notifier ChainNotifier
29	blockNtfnStream *BlockEpochEvent
30	current atomic.Pointer[BlockEpoch]
31	mu sync.Mutex
32	quit chan struct{}
33	wg sync.WaitGroup
34	}
35
36	// This is a compile time check to ensure that BestBlockTracker implements
37	// BestBlockView.
38	var _ BestBlockView = (*BestBlockTracker)(nil)
39
40	// NewBestBlockTracker creates a new BestBlockTracker that isn't running yet.
41	// It will not provide up to date information unless it has been started. The
42	// ChainNotifier parameter must also be started prior to starting the
43	// BestBlockTracker.
44	func NewBestBlockTracker(chainNotifier ChainNotifier) *BestBlockTracker {	1✔
45	return &BestBlockTracker{	1✔
46	notifier: chainNotifier,	1✔
47	blockNtfnStream: nil,	1✔
48	quit: make(chan struct{}),	1✔
49	}	1✔
50	}	1✔
51
52	// BestHeight gets the most recent block height known to the
53	// BestBlockTracker.
54	func (t *BestBlockTracker) BestHeight() (uint32, error) {	250✔
55	epoch := t.current.Load()	250✔
56	if epoch == nil {	250✔
57	return 0, errors.New("best block height not yet known")	×
58	}	×
59
60	return uint32(epoch.Height), nil	250✔
61	}
62
63	// BestBlockHeader gets the most recent block header known to the
64	// BestBlockTracker.
65	func (t BestBlockTracker) BestBlockHeader() (wire.BlockHeader, error) {	150✔
66	epoch := t.current.Load()	150✔
67	if epoch == nil {	150✔
68	return nil, errors.New("best block header not yet known")	×
69	}	×
70
71	return epoch.BlockHeader, nil	150✔
72	}
73
74	// updateLoop is a helper that subscribes to the underlying BlockEpochEvent
75	// stream and updates the internal values to match the new BlockEpochs that
76	// are discovered.
77	//
78	// MUST be run as a goroutine.
79	func (t *BestBlockTracker) updateLoop() {	1✔
80	defer t.wg.Done()	1✔
81	for {	102✔
82	select {	101✔
83	case epoch, ok := <-t.blockNtfnStream.Epochs:	100✔
84	if !ok {	100✔
UNCOV 85	Log.Error("dead epoch stream in " +	×
UNCOV 86	"BestBlockTracker")	×
UNCOV 87		×
UNCOV 88	return	×
UNCOV 89	}	×
90	t.current.Store(epoch)	100✔
91	case <-t.quit:	1✔
92	t.current.Store(nil)	1✔
93	return	1✔
94	}
95	}
96	}
97
98	// Start starts the BestBlockTracker. It is an error to start it if it
99	// is already started.
100	func (t *BestBlockTracker) Start() error {	1✔
101	t.mu.Lock()	1✔
102	defer t.mu.Unlock()	1✔
103		1✔
104	if t.blockNtfnStream != nil {	1✔
105	return fmt.Errorf("BestBlockTracker is already started")	×
106	}	×
107
108	var err error	1✔
109	t.blockNtfnStream, err = t.notifier.RegisterBlockEpochNtfn(nil)	1✔
110	if err != nil {	1✔
111	return err	×
112	}	×
113
114	t.wg.Add(1)	1✔
115	go t.updateLoop()	1✔
116		1✔
117	return nil	1✔
118	}
119
120	// Stop stops the BestBlockTracker. It is an error to stop it if it has
121	// not been started or if it has already been stopped.
122	func (t *BestBlockTracker) Stop() error {	1✔
123	t.mu.Lock()	1✔
124	defer t.mu.Unlock()	1✔
125		1✔
126	if t.blockNtfnStream == nil {	1✔
127	return fmt.Errorf("BestBlockTracker is not running")	×
128	}	×
129	close(t.quit)	1✔
130	t.wg.Wait()	1✔
131	t.blockNtfnStream.Cancel()	1✔
132	t.blockNtfnStream = nil	1✔
133		1✔
134	return nil	1✔
135	}

lightningnetwork / lnd / 12986279612

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