13928786996

Committed 18 Mar 2025 04:45PM UTC coverage: 68.795% (+0.2%) from 68.624%

Build # 13928786996

Build Type

Pull #9610

github

Committed by

web-flow

Commit Message

Merge 3681ba6d8 into c292acfe7

Pull Request Pull Request #9610: multi: integrate rbf changes from staging branch

Run Details

1132 of 1435 new or added lines in 22 files covered. (78.89%)

87 existing lines in 20 files now uncovered.

131495 of 191139 relevant lines covered (68.8%)

23414.49 hits per line

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

96.61

/peer/chan_observer.go

package peer

import (
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/htlcswitch"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwallet/chancloser"
)

// channelView is a view into the current active/global channel state machine
// for a given link.
type channelView interface {
        // OweCommitment returns a boolean value reflecting whether we need to
        // send out a commitment signature because there are outstanding local
        // updates and/or updates in the local commit tx that aren't reflected
        // in the remote commit tx yet.
        OweCommitment() bool

        // IsChannelClean returns true if neither side has pending commitments,
        // neither side has HTLC's, and all updates are locked in irrevocably.
        IsChannelClean() bool

        // MarkCoopBroadcasted persistently marks that the channel close
        // transaction has been broadcast.
        MarkCoopBroadcasted(*wire.MsgTx, lntypes.ChannelParty) error

        // StateSnapshot returns a snapshot of the current fully committed
        // state within the channel.
        StateSnapshot() *channeldb.ChannelSnapshot

        // MarkShutdownSent persists the given ShutdownInfo. The existence of
        // the ShutdownInfo represents the fact that the Shutdown message has
        // been sent by us and so should be re-sent on re-establish.
        MarkShutdownSent(info *channeldb.ShutdownInfo) error
}

// linkController is capable of controlling the flow out incoming/outgoing
// HTLCs to/from the link.
type linkController interface {
        // DisableAdds sets the ChannelUpdateHandler state to allow/reject
        // UpdateAddHtlc's in the specified direction. It returns true if the
        // state was changed and false if the desired state was already set
        // before the method was called.
        DisableAdds(outgoing bool) bool

        // IsFlushing returns true when UpdateAddHtlc's are disabled in the
        // direction of the argument.
        IsFlushing(direction bool) bool
}

// linkNetworkController is an interface that represents an object capable of
// managing interactions with the active channel links from the PoV of the
// gossip network.
type linkNetworkController interface {
        // RequestDisable disables a channel by its channel point.
        RequestDisable(wire.OutPoint, bool) error
}

// chanObserver implements the chancloser.ChanObserver interface for the
// existing LightningChannel struct/instance.
type chanObserver struct {
        chanView    channelView
        link        linkController
        linkNetwork linkNetworkController
}

// newChanObserver creates a new instance of a chanObserver from an active
// channelView.
func newChanObserver(chanView channelView,
        link linkController, linkNetwork linkNetworkController) *chanObserver {

        return &chanObserver{
                chanView:    chanView,
                link:        link,
                linkNetwork: linkNetwork,
        }
}

// NoDanglingUpdates returns true if there are no dangling updates in the
// channel. In other words, there are no active update messages that haven't
// already been covered by a commit sig.
func (l *chanObserver) NoDanglingUpdates() bool {
        return !l.chanView.OweCommitment()
}

// DisableIncomingAdds instructs the channel link to disable process new
// incoming add messages.
func (l *chanObserver) DisableIncomingAdds() error {
        // If there's no link, then we don't need to disable any adds.
        if l.link == nil {
                return nil
        }

        disabled := l.link.DisableAdds(htlcswitch.Incoming)
        if disabled {
                chanPoint := l.chanView.StateSnapshot().ChannelPoint
                peerLog.Debugf("ChannelPoint(%v): link already disabled",
                        chanPoint)
        }

        return nil
}

// DisableOutgoingAdds instructs the channel link to disable process new
// outgoing add messages.
func (l *chanObserver) DisableOutgoingAdds() error {
        // If there's no link, then we don't need to disable any adds.
        if l.link == nil {
                return nil
        }

        _ = l.link.DisableAdds(htlcswitch.Outgoing)

        return nil
}

// MarkCoopBroadcasted persistently marks that the channel close transaction
// has been broadcast.
func (l *chanObserver) MarkCoopBroadcasted(tx *wire.MsgTx, local bool) error {
        return l.chanView.MarkCoopBroadcasted(tx, lntypes.Local)
}

// MarkShutdownSent persists the given ShutdownInfo. The existence of the
// ShutdownInfo represents the fact that the Shutdown message has been sent by
// us and so should be re-sent on re-establish.
func (l *chanObserver) MarkShutdownSent(deliveryAddr []byte,
        isInitiator bool) error {

        shutdownInfo := channeldb.NewShutdownInfo(deliveryAddr, isInitiator)
        return l.chanView.MarkShutdownSent(shutdownInfo)
}

// FinalBalances is the balances of the channel once it has been flushed. If
// Some, then this indicates that the channel is now in a state where it's
// always flushed, so we can accelerate the state transitions.
func (l *chanObserver) FinalBalances() fn.Option[chancloser.ShutdownBalances] {
        chanClean := l.chanView.IsChannelClean()

        switch {
        // If we have a link, then the balances are final if both the incoming
        // and outgoing adds are disabled _and_ the channel is clean.
        case l.link != nil && l.link.IsFlushing(htlcswitch.Incoming) &&
                l.link.IsFlushing(htlcswitch.Outgoing) && chanClean:

                fallthrough

        // If we don't have a link, then this is a restart case, so the
        // balances are final.
        case l.link == nil:
                snapshot := l.chanView.StateSnapshot()

                return fn.Some(chancloser.ShutdownBalances{
                        LocalBalance:  snapshot.LocalBalance,
                        RemoteBalance: snapshot.RemoteBalance,
                })

        // Otherwise, the link is still active and not flushed, so the balances
        // aren't yet final.
        default:
                return fn.None[chancloser.ShutdownBalances]()
        }
}

// DisableChannel disables the target channel.
func (l *chanObserver) DisableChannel() error {
        op := l.chanView.StateSnapshot().ChannelPoint
        return l.linkNetwork.RequestDisable(op, false)
}

// A compile-time assertion to ensure that chanObserver meets the
// chancloser.ChanStateObserver interface.
var _ chancloser.ChanStateObserver = (*chanObserver)(nil)

1	package peer
2
3	import (
4	"github.com/btcsuite/btcd/wire"
5	"github.com/lightningnetwork/lnd/channeldb"
6	"github.com/lightningnetwork/lnd/fn/v2"
7	"github.com/lightningnetwork/lnd/htlcswitch"
8	"github.com/lightningnetwork/lnd/lntypes"
9	"github.com/lightningnetwork/lnd/lnwallet/chancloser"
10	)
11
12	// channelView is a view into the current active/global channel state machine
13	// for a given link.
14	type channelView interface {
15	// OweCommitment returns a boolean value reflecting whether we need to
16	// send out a commitment signature because there are outstanding local
17	// updates and/or updates in the local commit tx that aren't reflected
18	// in the remote commit tx yet.
19	OweCommitment() bool
20
21	// IsChannelClean returns true if neither side has pending commitments,
22	// neither side has HTLC's, and all updates are locked in irrevocably.
23	IsChannelClean() bool
24
25	// MarkCoopBroadcasted persistently marks that the channel close
26	// transaction has been broadcast.
27	MarkCoopBroadcasted(*wire.MsgTx, lntypes.ChannelParty) error
28
29	// StateSnapshot returns a snapshot of the current fully committed
30	// state within the channel.
31	StateSnapshot() *channeldb.ChannelSnapshot
32
33	// MarkShutdownSent persists the given ShutdownInfo. The existence of
34	// the ShutdownInfo represents the fact that the Shutdown message has
35	// been sent by us and so should be re-sent on re-establish.
36	MarkShutdownSent(info *channeldb.ShutdownInfo) error
37	}
38
39	// linkController is capable of controlling the flow out incoming/outgoing
40	// HTLCs to/from the link.
41	type linkController interface {
42	// DisableAdds sets the ChannelUpdateHandler state to allow/reject
43	// UpdateAddHtlc's in the specified direction. It returns true if the
44	// state was changed and false if the desired state was already set
45	// before the method was called.
46	DisableAdds(outgoing bool) bool
47
48	// IsFlushing returns true when UpdateAddHtlc's are disabled in the
49	// direction of the argument.
50	IsFlushing(direction bool) bool
51	}
52
53	// linkNetworkController is an interface that represents an object capable of
54	// managing interactions with the active channel links from the PoV of the
55	// gossip network.
56	type linkNetworkController interface {
57	// RequestDisable disables a channel by its channel point.
58	RequestDisable(wire.OutPoint, bool) error
59	}
60
61	// chanObserver implements the chancloser.ChanObserver interface for the
62	// existing LightningChannel struct/instance.
63	type chanObserver struct {
64	chanView channelView
65	link linkController
66	linkNetwork linkNetworkController
67	}
68
69	// newChanObserver creates a new instance of a chanObserver from an active
70	// channelView.
71	func newChanObserver(chanView channelView,
72	link linkController, linkNetwork linkNetworkController) *chanObserver {	3✔
73		3✔
74	return &chanObserver{	3✔
75	chanView: chanView,	3✔
76	link: link,	3✔
77	linkNetwork: linkNetwork,	3✔
78	}	3✔
79	}	3✔
80
81	// NoDanglingUpdates returns true if there are no dangling updates in the
82	// channel. In other words, there are no active update messages that haven't
83	// already been covered by a commit sig.
84	func (l *chanObserver) NoDanglingUpdates() bool {	3✔
85	return !l.chanView.OweCommitment()	3✔
86	}	3✔
87
88	// DisableIncomingAdds instructs the channel link to disable process new
89	// incoming add messages.
90	func (l *chanObserver) DisableIncomingAdds() error {	3✔
91	// If there's no link, then we don't need to disable any adds.	3✔
92	if l.link == nil {	6✔
93	return nil	3✔
94	}	3✔
95
96	disabled := l.link.DisableAdds(htlcswitch.Incoming)	3✔
97	if disabled {	6✔
98	chanPoint := l.chanView.StateSnapshot().ChannelPoint	3✔
99	peerLog.Debugf("ChannelPoint(%v): link already disabled",	3✔
100	chanPoint)	3✔
101	}	3✔
102
103	return nil	3✔
104	}
105
106	// DisableOutgoingAdds instructs the channel link to disable process new
107	// outgoing add messages.
108	func (l *chanObserver) DisableOutgoingAdds() error {	3✔
109	// If there's no link, then we don't need to disable any adds.	3✔
110	if l.link == nil {	3✔
NEW 111	return nil	×
NEW 112	}	×
113
114	_ = l.link.DisableAdds(htlcswitch.Outgoing)	3✔
115		3✔
116	return nil	3✔
117	}
118
119	// MarkCoopBroadcasted persistently marks that the channel close transaction
120	// has been broadcast.
121	func (l chanObserver) MarkCoopBroadcasted(tx wire.MsgTx, local bool) error {	3✔
122	return l.chanView.MarkCoopBroadcasted(tx, lntypes.Local)	3✔
123	}	3✔
124
125	// MarkShutdownSent persists the given ShutdownInfo. The existence of the
126	// ShutdownInfo represents the fact that the Shutdown message has been sent by
127	// us and so should be re-sent on re-establish.
128	func (l *chanObserver) MarkShutdownSent(deliveryAddr []byte,
129	isInitiator bool) error {	3✔
130		3✔
131	shutdownInfo := channeldb.NewShutdownInfo(deliveryAddr, isInitiator)	3✔
132	return l.chanView.MarkShutdownSent(shutdownInfo)	3✔
133	}	3✔
134
135	// FinalBalances is the balances of the channel once it has been flushed. If
136	// Some, then this indicates that the channel is now in a state where it's
137	// always flushed, so we can accelerate the state transitions.
138	func (l *chanObserver) FinalBalances() fn.Option[chancloser.ShutdownBalances] {	3✔
139	chanClean := l.chanView.IsChannelClean()	3✔
140		3✔
141	switch {	3✔
142	// If we have a link, then the balances are final if both the incoming
143	// and outgoing adds are disabled _and_ the channel is clean.
144	case l.link != nil && l.link.IsFlushing(htlcswitch.Incoming) &&
145	l.link.IsFlushing(htlcswitch.Outgoing) && chanClean:	3✔
146		3✔
147	fallthrough	3✔
148
149	// If we don't have a link, then this is a restart case, so the
150	// balances are final.
151	case l.link == nil:	3✔
152	snapshot := l.chanView.StateSnapshot()	3✔
153		3✔
154	return fn.Some(chancloser.ShutdownBalances{	3✔
155	LocalBalance: snapshot.LocalBalance,	3✔
156	RemoteBalance: snapshot.RemoteBalance,	3✔
157	})	3✔
158
159	// Otherwise, the link is still active and not flushed, so the balances
160	// aren't yet final.
161	default:	3✔
162	return fn.None[chancloser.ShutdownBalances]()	3✔
163	}
164	}
165
166	// DisableChannel disables the target channel.
167	func (l *chanObserver) DisableChannel() error {	3✔
168	op := l.chanView.StateSnapshot().ChannelPoint	3✔
169	return l.linkNetwork.RequestDisable(op, false)	3✔
170	}	3✔
171
172	// A compile-time assertion to ensure that chanObserver meets the
173	// chancloser.ChanStateObserver interface.
174	var _ chancloser.ChanStateObserver = (*chanObserver)(nil)

lightningnetwork / lnd / 13928786996

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