13157733617

Committed 05 Feb 2025 12:49PM UTC coverage: 57.712% (-1.1%) from 58.82%

Build # 13157733617

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%)

19472 existing lines in 252 files now uncovered.

103634 of 179570 relevant lines covered (57.71%)

24840.31 hits per line

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

54.93

/contractcourt/breach_resolver.go

package contractcourt

import (
        "encoding/binary"
        "fmt"
        "io"

        "github.com/lightningnetwork/lnd/channeldb"
)

// breachResolver is a resolver that will handle breached closes. In the
// future, this will likely take over the duties the current BreachArbitrator
// has.
type breachResolver struct {
        // subscribed denotes whether or not the breach resolver has subscribed
        // to the BreachArbitrator for breach resolution.
        subscribed bool

        // replyChan is closed when the breach arbiter has completed serving
        // justice.
        replyChan chan struct{}

        contractResolverKit
}

// newBreachResolver instantiates a new breach resolver.
func newBreachResolver(resCfg ResolverConfig) *breachResolver {
        r := &breachResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
                replyChan:           make(chan struct{}),
        }

        r.initLogger(fmt.Sprintf("%T(%v)", r, r.ChanPoint))

        return r
}

// ResolverKey returns the unique identifier for this resolver.
func (b *breachResolver) ResolverKey() []byte {
        key := newResolverID(b.ChanPoint)
        return key[:]
}

// Resolve queries the BreachArbitrator to see if the justice transaction has
// been broadcast.
//
// NOTE: Part of the ContractResolver interface.
//
// TODO(yy): let sweeper handle the breach inputs.
func (b *breachResolver) Resolve() (ContractResolver, error) {
        if !b.subscribed {
                complete, err := b.SubscribeBreachComplete(
                        &b.ChanPoint, b.replyChan,
                )
                if err != nil {
                        return nil, err
                }

                // If the breach resolution process is already complete, then
                // we can cleanup and checkpoint the resolved state.
                if complete {
                        b.markResolved()
                        return nil, b.Checkpoint(b)
                }

                // Prevent duplicate subscriptions.
                b.subscribed = true
        }

        select {
        case <-b.replyChan:
                // The replyChan has been closed, signalling that the breach
                // has been fully resolved. Checkpoint the resolved state and
                // exit.
                b.markResolved()
                return nil, b.Checkpoint(b)

        case <-b.quit:
        }

        return nil, errResolverShuttingDown
}

// Stop signals the breachResolver to stop.
func (b *breachResolver) Stop() {
        b.log.Debugf("stopping...")
        close(b.quit)
}

// SupplementState adds additional state to the breachResolver.
func (b *breachResolver) SupplementState(_ *channeldb.OpenChannel) {
}

// Encode encodes the breachResolver to the passed writer.
func (b *breachResolver) Encode(w io.Writer) error {
        return binary.Write(w, endian, b.IsResolved())
}

// newBreachResolverFromReader attempts to decode an encoded breachResolver
// from the passed Reader instance, returning an active breachResolver.
func newBreachResolverFromReader(r io.Reader, resCfg ResolverConfig) (
        *breachResolver, error) {

        b := &breachResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
                replyChan:           make(chan struct{}),
        }

        var resolved bool
        if err := binary.Read(r, endian, &resolved); err != nil {
                return nil, err
        }
        if resolved {
                b.markResolved()
        }

        b.initLogger(fmt.Sprintf("%T(%v)", b, b.ChanPoint))

        return b, nil
}

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

// Launch offers the breach outputs to the sweeper - currently it's a NOOP as
// the outputs here are not offered to the sweeper.
//
// NOTE: Part of the ContractResolver interface.
//
// TODO(yy): implement it once the outputs are offered to the sweeper.
func (b *breachResolver) Launch() error {
        if b.isLaunched() {
                b.log.Tracef("already launched")
                return nil
        }

        b.log.Debugf("launching resolver...")
        b.markLaunched()

        return nil
}

1	package contractcourt
2
3	import (
4	"encoding/binary"
5	"fmt"
6	"io"
7
8	"github.com/lightningnetwork/lnd/channeldb"
9	)
10
11	// breachResolver is a resolver that will handle breached closes. In the
12	// future, this will likely take over the duties the current BreachArbitrator
13	// has.
14	type breachResolver struct {
15	// subscribed denotes whether or not the breach resolver has subscribed
16	// to the BreachArbitrator for breach resolution.
17	subscribed bool
18
19	// replyChan is closed when the breach arbiter has completed serving
20	// justice.
21	replyChan chan struct{}
22
23	contractResolverKit
24	}
25
26	// newBreachResolver instantiates a new breach resolver.
27	func newBreachResolver(resCfg ResolverConfig) *breachResolver {	2✔
28	r := &breachResolver{	2✔
29	contractResolverKit: *newContractResolverKit(resCfg),	2✔
30	replyChan: make(chan struct{}),	2✔
31	}	2✔
32		2✔
33	r.initLogger(fmt.Sprintf("%T(%v)", r, r.ChanPoint))	2✔
34		2✔
35	return r	2✔
36	}	2✔
37
38	// ResolverKey returns the unique identifier for this resolver.
39	func (b *breachResolver) ResolverKey() []byte {	4✔
40	key := newResolverID(b.ChanPoint)	4✔
41	return key[:]	4✔
42	}	4✔
43
44	// Resolve queries the BreachArbitrator to see if the justice transaction has
45	// been broadcast.
46	//
47	// NOTE: Part of the ContractResolver interface.
48	//
49	// TODO(yy): let sweeper handle the breach inputs.
50	func (b *breachResolver) Resolve() (ContractResolver, error) {	2✔
51	if !b.subscribed {	4✔
52	complete, err := b.SubscribeBreachComplete(	2✔
53	&b.ChanPoint, b.replyChan,	2✔
54	)	2✔
55	if err != nil {	2✔
56	return nil, err	×
57	}	×
58
59	// If the breach resolution process is already complete, then
60	// we can cleanup and checkpoint the resolved state.
61	if complete {	2✔
62	b.markResolved()	×
63	return nil, b.Checkpoint(b)	×
64	}	×
65
66	// Prevent duplicate subscriptions.
67	b.subscribed = true	2✔
68	}
69
70	select {	2✔
71	case <-b.replyChan:	2✔
72	// The replyChan has been closed, signalling that the breach	2✔
73	// has been fully resolved. Checkpoint the resolved state and	2✔
74	// exit.	2✔
75	b.markResolved()	2✔
76	return nil, b.Checkpoint(b)	2✔
77
UNCOV 78	case <-b.quit:	×
79	}
80
UNCOV 81	return nil, errResolverShuttingDown	×
82	}
83
84	// Stop signals the breachResolver to stop.
85	func (b *breachResolver) Stop() {	2✔
86	b.log.Debugf("stopping...")	2✔
87	close(b.quit)	2✔
88	}	2✔
89
90	// SupplementState adds additional state to the breachResolver.
UNCOV 91	func (b breachResolver) SupplementState(_ channeldb.OpenChannel) {	×
UNCOV 92	}	×
93
94	// Encode encodes the breachResolver to the passed writer.
UNCOV 95	func (b *breachResolver) Encode(w io.Writer) error {	×
UNCOV 96	return binary.Write(w, endian, b.IsResolved())	×
UNCOV 97	}	×
98
99	// newBreachResolverFromReader attempts to decode an encoded breachResolver
100	// from the passed Reader instance, returning an active breachResolver.
101	func newBreachResolverFromReader(r io.Reader, resCfg ResolverConfig) (
UNCOV 102	*breachResolver, error) {	×
UNCOV 103		×
UNCOV 104	b := &breachResolver{	×
UNCOV 105	contractResolverKit: *newContractResolverKit(resCfg),	×
UNCOV 106	replyChan: make(chan struct{}),	×
UNCOV 107	}	×
UNCOV 108		×
UNCOV 109	var resolved bool	×
UNCOV 110	if err := binary.Read(r, endian, &resolved); err != nil {	×
111	return nil, err	×
112	}	×
UNCOV 113	if resolved {	×
UNCOV 114	b.markResolved()	×
UNCOV 115	}	×
116
UNCOV 117	b.initLogger(fmt.Sprintf("%T(%v)", b, b.ChanPoint))	×
UNCOV 118		×
UNCOV 119	return b, nil	×
120	}
121
122	// A compile time assertion to ensure breachResolver meets the ContractResolver
123	// interface.
124	var _ ContractResolver = (*breachResolver)(nil)
125
126	// Launch offers the breach outputs to the sweeper - currently it's a NOOP as
127	// the outputs here are not offered to the sweeper.
128	//
129	// NOTE: Part of the ContractResolver interface.
130	//
131	// TODO(yy): implement it once the outputs are offered to the sweeper.
132	func (b *breachResolver) Launch() error {	2✔
133	if b.isLaunched() {	2✔
UNCOV 134	b.log.Tracef("already launched")	×
UNCOV 135	return nil	×
UNCOV 136	}	×
137
138	b.log.Debugf("launching resolver...")	2✔
139	b.markLaunched()	2✔
140		2✔
141	return nil	2✔
142	}

lightningnetwork / lnd / 13157733617

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