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

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✔
UNCOV 62	b.markResolved()	×
UNCOV 63	return nil, b.Checkpoint(b)	×
UNCOV 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 / 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