15561477203

Committed 10 Jun 2025 01:54PM UTC coverage: 58.351% (-10.1%) from 68.487%

Build # 15561477203

Build Type

Pull #9356

github

Committed by

web-flow

Commit Message

Merge 6440b25db into c6d6d4c0b

Pull Request Pull Request #9356: lnrpc: add incoming/outgoing channel ids filter to forwarding history request

Run Details

33 of 36 new or added lines in 2 files covered. (91.67%)

28366 existing lines in 455 files now uncovered.

97715 of 167461 relevant lines covered (58.35%)

1.81 hits per line

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

45.53

/funding/commitment_type_negotiation.go

package funding

import (
        "errors"

        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/lnwire"
)

var (
        // errUnsupportedCommitmentType is an error returned when a specific
        // channel commitment type is being explicitly negotiated but either
        // peer of the channel does not support it.
        errUnsupportedChannelType = errors.New("requested channel type " +
                "not supported")
)

// negotiateCommitmentType negotiates the commitment type of a newly opened
// channel. If a desiredChanType is provided, explicit negotiation for said type
// will be attempted if the set of both local and remote features support it.
// Otherwise, implicit negotiation will be attempted.
//
// The returned ChannelType is nil when implicit negotiation is used. An error
// is only returned if desiredChanType is not supported.
func negotiateCommitmentType(desiredChanType *lnwire.ChannelType, local,
        remote *lnwire.FeatureVector) (*lnwire.ChannelType,
        lnwallet.CommitmentType, error) {

        // BOLT#2 specifies we MUST use explicit negotiation if both peers
        // signal for it.
        explicitNegotiation := hasFeatures(
                local, remote, lnwire.ExplicitChannelTypeOptional,
        )

        chanTypeRequested := desiredChanType != nil

        switch {
        case explicitNegotiation && chanTypeRequested:
                commitType, err := explicitNegotiateCommitmentType(
                        *desiredChanType, local, remote,
                )

                return desiredChanType, commitType, err

        // We don't have a specific channel type requested, so we select a
        // default type as if implicit negotiation were used, and then we
        // explicitly signal that default type.
        case explicitNegotiation && !chanTypeRequested:
                defaultChanType, commitType := implicitNegotiateCommitmentType(
                        local, remote,
                )

                return defaultChanType, commitType, nil

        // A specific channel type was requested, but we can't explicitly signal
        // it. So if implicit negotiation wouldn't select the desired channel
        // type, we must return an error.
        case !explicitNegotiation && chanTypeRequested:
                implicitChanType, commitType := implicitNegotiateCommitmentType(
                        local, remote,
                )

                expected := lnwire.RawFeatureVector(*desiredChanType)
                actual := lnwire.RawFeatureVector(*implicitChanType)
                if !expected.Equals(&actual) {
                        return nil, 0, errUnsupportedChannelType
                }

                return nil, commitType, nil

        default: // !explicitNegotiation && !chanTypeRequested
                _, commitType := implicitNegotiateCommitmentType(local, remote)

                return nil, commitType, nil
        }
}

// explicitNegotiateCommitmentType attempts to explicitly negotiate for a
// specific channel type. Since the channel type is comprised of a set of even
// feature bits, we also make sure each feature is supported by both peers. An
// error is returned if either peer does not support said channel type.
func explicitNegotiateCommitmentType(channelType lnwire.ChannelType, local,
        remote *lnwire.FeatureVector) (lnwallet.CommitmentType, error) {

        channelFeatures := lnwire.RawFeatureVector(channelType)

        switch {
        // Lease script enforcement + anchors zero fee + static remote key +
        // zero conf + scid alias features only.
        case channelFeatures.OnlyContains(
                lnwire.ZeroConfRequired,
                lnwire.ScidAliasRequired,
                lnwire.ScriptEnforcedLeaseRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ZeroConfOptional,
                        lnwire.ScriptEnforcedLeaseOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeScriptEnforcedLease, nil

        // Anchors zero fee + static remote key + zero conf + scid alias
        // features only.
        case channelFeatures.OnlyContains(
                lnwire.ZeroConfRequired,
                lnwire.ScidAliasRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ZeroConfOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil

        // Lease script enforcement + anchors zero fee + static remote key +
        // zero conf features only.
        case channelFeatures.OnlyContains(
                lnwire.ZeroConfRequired,
                lnwire.ScriptEnforcedLeaseRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ZeroConfOptional,
                        lnwire.ScriptEnforcedLeaseOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeScriptEnforcedLease, nil

        // Anchors zero fee + static remote key + zero conf features only.
        case channelFeatures.OnlyContains(
                lnwire.ZeroConfRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ZeroConfOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil

        // Lease script enforcement + anchors zero fee + static remote key +
        // option-scid-alias features only.
        case channelFeatures.OnlyContains(
                lnwire.ScidAliasRequired,
                lnwire.ScriptEnforcedLeaseRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ScidAliasOptional,
                        lnwire.ScriptEnforcedLeaseOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeScriptEnforcedLease, nil

        // Anchors zero fee + static remote key + option-scid-alias features
        // only.
        case channelFeatures.OnlyContains(
                lnwire.ScidAliasRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ScidAliasOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil

        // Lease script enforcement + anchors zero fee + static remote key
        // features only.
        case channelFeatures.OnlyContains(
                lnwire.ScriptEnforcedLeaseRequired,
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.ScriptEnforcedLeaseOptional,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeScriptEnforcedLease, nil

        // Anchors zero fee + static remote key features only.
        case channelFeatures.OnlyContains(
                lnwire.AnchorsZeroFeeHtlcTxRequired,
                lnwire.StaticRemoteKeyRequired,
        ):
                if !hasFeatures(
                        local, remote,
                        lnwire.AnchorsZeroFeeHtlcTxOptional,
                        lnwire.StaticRemoteKeyOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil

        // Static remote key feature only.
        case channelFeatures.OnlyContains(lnwire.StaticRemoteKeyRequired):
                if !hasFeatures(local, remote, lnwire.StaticRemoteKeyOptional) {
                        return 0, errUnsupportedChannelType
                }
                return lnwallet.CommitmentTypeTweakless, nil

        // Simple taproot channels only.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootChannelsRequiredStaging,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootChannelsOptionalStaging,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaproot, nil

        // Simple taproot channels with scid only.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootChannelsRequiredStaging,
                lnwire.ScidAliasRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootChannelsOptionalStaging,
                        lnwire.ScidAliasOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaproot, nil

        // Simple taproot channels with zero conf only.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootChannelsRequiredStaging,
                lnwire.ZeroConfRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootChannelsOptionalStaging,
                        lnwire.ZeroConfOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaproot, nil

        // Simple taproot channels with scid and zero conf.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootChannelsRequiredStaging,
                lnwire.ZeroConfRequired,
                lnwire.ScidAliasRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootChannelsOptionalStaging,
                        lnwire.ZeroConfOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaproot, nil

        // Simple taproot channels overlay only.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootOverlayChansRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootOverlayChansOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil

        // Simple taproot overlay channels with scid only.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootOverlayChansRequired,
                lnwire.ScidAliasRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootOverlayChansOptional,
                        lnwire.ScidAliasOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil

        // Simple taproot overlay channels with zero conf only.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootOverlayChansRequired,
                lnwire.ZeroConfRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootOverlayChansOptional,
                        lnwire.ZeroConfOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil

        // Simple taproot overlay channels with scid and zero conf.
        case channelFeatures.OnlyContains(
                lnwire.SimpleTaprootOverlayChansRequired,
                lnwire.ZeroConfRequired,
                lnwire.ScidAliasRequired,
        ):

                if !hasFeatures(
                        local, remote,
                        lnwire.SimpleTaprootOverlayChansOptional,
                        lnwire.ZeroConfOptional,
                        lnwire.ScidAliasOptional,
                ) {

                        return 0, errUnsupportedChannelType
                }

                return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil

        // No features, use legacy commitment type.
        case channelFeatures.IsEmpty():
                return lnwallet.CommitmentTypeLegacy, nil

        default:
                return 0, errUnsupportedChannelType
        }
}

// implicitNegotiateCommitmentType negotiates the commitment type of a channel
// implicitly by choosing the latest type supported by the local and remote
// features.
func implicitNegotiateCommitmentType(local,
        remote *lnwire.FeatureVector) (*lnwire.ChannelType,
        lnwallet.CommitmentType) {

        // If both peers are signalling support for anchor commitments with
        // zero-fee HTLC transactions, we'll use this type.
        if hasFeatures(local, remote, lnwire.AnchorsZeroFeeHtlcTxOptional) {
                chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(
                        lnwire.AnchorsZeroFeeHtlcTxRequired,
                        lnwire.StaticRemoteKeyRequired,
                ))

                return &chanType, lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx
        }

        // Since we don't want to support the "legacy" anchor type, we will fall
        // back to static remote key if the nodes don't support the zero fee
        // HTLC tx anchor type.
        //
        // If both nodes are signaling the proper feature bit for tweakless
        // commitments, we'll use that.
        if hasFeatures(local, remote, lnwire.StaticRemoteKeyOptional) {
                chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(
                        lnwire.StaticRemoteKeyRequired,
                ))

                return &chanType, lnwallet.CommitmentTypeTweakless
        }

        // Otherwise we'll fall back to the legacy type.
        chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector())
        return &chanType, lnwallet.CommitmentTypeLegacy
}

// hasFeatures determines whether a set of features is supported by both the set
// of local and remote features.
func hasFeatures(local, remote *lnwire.FeatureVector,
        features ...lnwire.FeatureBit) bool {

        for _, feature := range features {
                if !local.HasFeature(feature) || !remote.HasFeature(feature) {
                        return false
                }
        }
        return true
}

1	package funding
2
3	import (
4	"errors"
5
6	"github.com/lightningnetwork/lnd/lnwallet"
7	"github.com/lightningnetwork/lnd/lnwire"
8	)
9
10	var (
11	// errUnsupportedCommitmentType is an error returned when a specific
12	// channel commitment type is being explicitly negotiated but either
13	// peer of the channel does not support it.
14	errUnsupportedChannelType = errors.New("requested channel type " +
15	"not supported")
16	)
17
18	// negotiateCommitmentType negotiates the commitment type of a newly opened
19	// channel. If a desiredChanType is provided, explicit negotiation for said type
20	// will be attempted if the set of both local and remote features support it.
21	// Otherwise, implicit negotiation will be attempted.
22	//
23	// The returned ChannelType is nil when implicit negotiation is used. An error
24	// is only returned if desiredChanType is not supported.
25	func negotiateCommitmentType(desiredChanType *lnwire.ChannelType, local,
26	remote lnwire.FeatureVector) (lnwire.ChannelType,
27	lnwallet.CommitmentType, error) {	3✔
28		3✔
29	// BOLT#2 specifies we MUST use explicit negotiation if both peers	3✔
30	// signal for it.	3✔
31	explicitNegotiation := hasFeatures(	3✔
32	local, remote, lnwire.ExplicitChannelTypeOptional,	3✔
33	)	3✔
34		3✔
35	chanTypeRequested := desiredChanType != nil	3✔
36		3✔
37	switch {	3✔
38	case explicitNegotiation && chanTypeRequested:	3✔
39	commitType, err := explicitNegotiateCommitmentType(	3✔
40	*desiredChanType, local, remote,	3✔
41	)	3✔
42		3✔
43	return desiredChanType, commitType, err	3✔
44
45	// We don't have a specific channel type requested, so we select a
46	// default type as if implicit negotiation were used, and then we
47	// explicitly signal that default type.
48	case explicitNegotiation && !chanTypeRequested:	3✔
49	defaultChanType, commitType := implicitNegotiateCommitmentType(	3✔
50	local, remote,	3✔
51	)	3✔
52		3✔
53	return defaultChanType, commitType, nil	3✔
54
55	// A specific channel type was requested, but we can't explicitly signal
56	// it. So if implicit negotiation wouldn't select the desired channel
57	// type, we must return an error.
UNCOV 58	case !explicitNegotiation && chanTypeRequested:	×
UNCOV 59	implicitChanType, commitType := implicitNegotiateCommitmentType(	×
UNCOV 60	local, remote,	×
UNCOV 61	)	×
UNCOV 62		×
UNCOV 63	expected := lnwire.RawFeatureVector(*desiredChanType)	×
UNCOV 64	actual := lnwire.RawFeatureVector(*implicitChanType)	×
UNCOV 65	if !expected.Equals(&actual) {	×
66	return nil, 0, errUnsupportedChannelType	×
67	}	×
68
UNCOV 69	return nil, commitType, nil	×
70
UNCOV 71	default: // !explicitNegotiation && !chanTypeRequested	×
UNCOV 72	_, commitType := implicitNegotiateCommitmentType(local, remote)	×
UNCOV 73		×
UNCOV 74	return nil, commitType, nil	×
75	}
76	}
77
78	// explicitNegotiateCommitmentType attempts to explicitly negotiate for a
79	// specific channel type. Since the channel type is comprised of a set of even
80	// feature bits, we also make sure each feature is supported by both peers. An
81	// error is returned if either peer does not support said channel type.
82	func explicitNegotiateCommitmentType(channelType lnwire.ChannelType, local,
83	remote *lnwire.FeatureVector) (lnwallet.CommitmentType, error) {	3✔
84		3✔
85	channelFeatures := lnwire.RawFeatureVector(channelType)	3✔
86		3✔
87	switch {	3✔
88	// Lease script enforcement + anchors zero fee + static remote key +
89	// zero conf + scid alias features only.
90	case channelFeatures.OnlyContains(
91	lnwire.ZeroConfRequired,
92	lnwire.ScidAliasRequired,
93	lnwire.ScriptEnforcedLeaseRequired,
94	lnwire.AnchorsZeroFeeHtlcTxRequired,
95	lnwire.StaticRemoteKeyRequired,
96	):	×
97	if !hasFeatures(	×
98	local, remote,	×
99	lnwire.ZeroConfOptional,	×
100	lnwire.ScriptEnforcedLeaseOptional,	×
101	lnwire.AnchorsZeroFeeHtlcTxOptional,	×
102	lnwire.StaticRemoteKeyOptional,	×
103	) {	×
104		×
105	return 0, errUnsupportedChannelType	×
106	}	×
107	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	×
108
109	// Anchors zero fee + static remote key + zero conf + scid alias
110	// features only.
111	case channelFeatures.OnlyContains(
112	lnwire.ZeroConfRequired,
113	lnwire.ScidAliasRequired,
114	lnwire.AnchorsZeroFeeHtlcTxRequired,
115	lnwire.StaticRemoteKeyRequired,
116	):	×
117	if !hasFeatures(	×
118	local, remote,	×
119	lnwire.ZeroConfOptional,	×
120	lnwire.AnchorsZeroFeeHtlcTxOptional,	×
121	lnwire.StaticRemoteKeyOptional,	×
122	) {	×
123		×
124	return 0, errUnsupportedChannelType	×
125	}	×
126	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	×
127
128	// Lease script enforcement + anchors zero fee + static remote key +
129	// zero conf features only.
130	case channelFeatures.OnlyContains(
131	lnwire.ZeroConfRequired,
132	lnwire.ScriptEnforcedLeaseRequired,
133	lnwire.AnchorsZeroFeeHtlcTxRequired,
134	lnwire.StaticRemoteKeyRequired,
135	):	3✔
136	if !hasFeatures(	3✔
137	local, remote,	3✔
138	lnwire.ZeroConfOptional,	3✔
139	lnwire.ScriptEnforcedLeaseOptional,	3✔
140	lnwire.AnchorsZeroFeeHtlcTxOptional,	3✔
141	lnwire.StaticRemoteKeyOptional,	3✔
142	) {	3✔
143		×
144	return 0, errUnsupportedChannelType	×
145	}	×
146	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	3✔
147
148	// Anchors zero fee + static remote key + zero conf features only.
149	case channelFeatures.OnlyContains(
150	lnwire.ZeroConfRequired,
151	lnwire.AnchorsZeroFeeHtlcTxRequired,
152	lnwire.StaticRemoteKeyRequired,
153	):	3✔
154	if !hasFeatures(	3✔
155	local, remote,	3✔
156	lnwire.ZeroConfOptional,	3✔
157	lnwire.AnchorsZeroFeeHtlcTxOptional,	3✔
158	lnwire.StaticRemoteKeyOptional,	3✔
159	) {	3✔
160		×
161	return 0, errUnsupportedChannelType	×
162	}	×
163	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	3✔
164
165	// Lease script enforcement + anchors zero fee + static remote key +
166	// option-scid-alias features only.
167	case channelFeatures.OnlyContains(
168	lnwire.ScidAliasRequired,
169	lnwire.ScriptEnforcedLeaseRequired,
170	lnwire.AnchorsZeroFeeHtlcTxRequired,
171	lnwire.StaticRemoteKeyRequired,
UNCOV 172	):	×
UNCOV 173	if !hasFeatures(	×
UNCOV 174	local, remote,	×
UNCOV 175	lnwire.ScidAliasOptional,	×
UNCOV 176	lnwire.ScriptEnforcedLeaseOptional,	×
UNCOV 177	lnwire.AnchorsZeroFeeHtlcTxOptional,	×
UNCOV 178	lnwire.StaticRemoteKeyOptional,	×
UNCOV 179	) {	×
180		×
181	return 0, errUnsupportedChannelType	×
182	}	×
UNCOV 183	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	×
184
185	// Anchors zero fee + static remote key + option-scid-alias features
186	// only.
187	case channelFeatures.OnlyContains(
188	lnwire.ScidAliasRequired,
189	lnwire.AnchorsZeroFeeHtlcTxRequired,
190	lnwire.StaticRemoteKeyRequired,
191	):	3✔
192	if !hasFeatures(	3✔
193	local, remote,	3✔
194	lnwire.ScidAliasOptional,	3✔
195	lnwire.AnchorsZeroFeeHtlcTxOptional,	3✔
196	lnwire.StaticRemoteKeyOptional,	3✔
197	) {	3✔
198		×
199	return 0, errUnsupportedChannelType	×
200	}	×
201	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	3✔
202
203	// Lease script enforcement + anchors zero fee + static remote key
204	// features only.
205	case channelFeatures.OnlyContains(
206	lnwire.ScriptEnforcedLeaseRequired,
207	lnwire.AnchorsZeroFeeHtlcTxRequired,
208	lnwire.StaticRemoteKeyRequired,
209	):	3✔
210	if !hasFeatures(	3✔
211	local, remote,	3✔
212	lnwire.ScriptEnforcedLeaseOptional,	3✔
213	lnwire.AnchorsZeroFeeHtlcTxOptional,	3✔
214	lnwire.StaticRemoteKeyOptional,	3✔
215	) {	3✔
216		×
217	return 0, errUnsupportedChannelType	×
218	}	×
219	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	3✔
220
221	// Anchors zero fee + static remote key features only.
222	case channelFeatures.OnlyContains(
223	lnwire.AnchorsZeroFeeHtlcTxRequired,
224	lnwire.StaticRemoteKeyRequired,
225	):	3✔
226	if !hasFeatures(	3✔
227	local, remote,	3✔
228	lnwire.AnchorsZeroFeeHtlcTxOptional,	3✔
229	lnwire.StaticRemoteKeyOptional,	3✔
230	) {	3✔
UNCOV 231		×
UNCOV 232	return 0, errUnsupportedChannelType	×
UNCOV 233	}	×
234	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	3✔
235
236	// Static remote key feature only.
237	case channelFeatures.OnlyContains(lnwire.StaticRemoteKeyRequired):	3✔
238	if !hasFeatures(local, remote, lnwire.StaticRemoteKeyOptional) {	3✔
239	return 0, errUnsupportedChannelType	×
240	}	×
241	return lnwallet.CommitmentTypeTweakless, nil	3✔
242
243	// Simple taproot channels only.
244	case channelFeatures.OnlyContains(
245	lnwire.SimpleTaprootChannelsRequiredStaging,
246	):	3✔
247		3✔
248	if !hasFeatures(	3✔
249	local, remote,	3✔
250	lnwire.SimpleTaprootChannelsOptionalStaging,	3✔
251	) {	6✔
252		3✔
253	return 0, errUnsupportedChannelType	3✔
254	}	3✔
255
256	return lnwallet.CommitmentTypeSimpleTaproot, nil	3✔
257
258	// Simple taproot channels with scid only.
259	case channelFeatures.OnlyContains(
260	lnwire.SimpleTaprootChannelsRequiredStaging,
261	lnwire.ScidAliasRequired,
262	):	×
263		×
264	if !hasFeatures(	×
265	local, remote,	×
266	lnwire.SimpleTaprootChannelsOptionalStaging,	×
267	lnwire.ScidAliasOptional,	×
268	) {	×
269		×
270	return 0, errUnsupportedChannelType	×
271	}	×
272
273	return lnwallet.CommitmentTypeSimpleTaproot, nil	×
274
275	// Simple taproot channels with zero conf only.
276	case channelFeatures.OnlyContains(
277	lnwire.SimpleTaprootChannelsRequiredStaging,
278	lnwire.ZeroConfRequired,
279	):	3✔
280		3✔
281	if !hasFeatures(	3✔
282	local, remote,	3✔
283	lnwire.SimpleTaprootChannelsOptionalStaging,	3✔
284	lnwire.ZeroConfOptional,	3✔
285	) {	3✔
286		×
287	return 0, errUnsupportedChannelType	×
288	}	×
289
290	return lnwallet.CommitmentTypeSimpleTaproot, nil	3✔
291
292	// Simple taproot channels with scid and zero conf.
293	case channelFeatures.OnlyContains(
294	lnwire.SimpleTaprootChannelsRequiredStaging,
295	lnwire.ZeroConfRequired,
296	lnwire.ScidAliasRequired,
297	):	×
298		×
299	if !hasFeatures(	×
300	local, remote,	×
301	lnwire.SimpleTaprootChannelsOptionalStaging,	×
302	lnwire.ZeroConfOptional,	×
303	) {	×
304		×
305	return 0, errUnsupportedChannelType	×
306	}	×
307
308	return lnwallet.CommitmentTypeSimpleTaproot, nil	×
309
310	// Simple taproot channels overlay only.
311	case channelFeatures.OnlyContains(
312	lnwire.SimpleTaprootOverlayChansRequired,
313	):	×
314		×
315	if !hasFeatures(	×
316	local, remote,	×
317	lnwire.SimpleTaprootOverlayChansOptional,	×
318	) {	×
319		×
320	return 0, errUnsupportedChannelType	×
321	}	×
322
323	return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil	×
324
325	// Simple taproot overlay channels with scid only.
326	case channelFeatures.OnlyContains(
327	lnwire.SimpleTaprootOverlayChansRequired,
328	lnwire.ScidAliasRequired,
329	):	×
330		×
331	if !hasFeatures(	×
332	local, remote,	×
333	lnwire.SimpleTaprootOverlayChansOptional,	×
334	lnwire.ScidAliasOptional,	×
335	) {	×
336		×
337	return 0, errUnsupportedChannelType	×
338	}	×
339
340	return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil	×
341
342	// Simple taproot overlay channels with zero conf only.
343	case channelFeatures.OnlyContains(
344	lnwire.SimpleTaprootOverlayChansRequired,
345	lnwire.ZeroConfRequired,
346	):	×
347		×
348	if !hasFeatures(	×
349	local, remote,	×
350	lnwire.SimpleTaprootOverlayChansOptional,	×
351	lnwire.ZeroConfOptional,	×
352	) {	×
353		×
354	return 0, errUnsupportedChannelType	×
355	}	×
356
357	return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil	×
358
359	// Simple taproot overlay channels with scid and zero conf.
360	case channelFeatures.OnlyContains(
361	lnwire.SimpleTaprootOverlayChansRequired,
362	lnwire.ZeroConfRequired,
363	lnwire.ScidAliasRequired,
364	):	×
365		×
366	if !hasFeatures(	×
367	local, remote,	×
368	lnwire.SimpleTaprootOverlayChansOptional,	×
369	lnwire.ZeroConfOptional,	×
370	lnwire.ScidAliasOptional,	×
371	) {	×
372		×
373	return 0, errUnsupportedChannelType	×
374	}	×
375
376	return lnwallet.CommitmentTypeSimpleTaprootOverlay, nil	×
377
378	// No features, use legacy commitment type.
379	case channelFeatures.IsEmpty():	3✔
380	return lnwallet.CommitmentTypeLegacy, nil	3✔
381
382	default:	×
383	return 0, errUnsupportedChannelType	×
384	}
385	}
386
387	// implicitNegotiateCommitmentType negotiates the commitment type of a channel
388	// implicitly by choosing the latest type supported by the local and remote
389	// features.
390	func implicitNegotiateCommitmentType(local,
391	remote lnwire.FeatureVector) (lnwire.ChannelType,
392	lnwallet.CommitmentType) {	3✔
393		3✔
394	// If both peers are signalling support for anchor commitments with	3✔
395	// zero-fee HTLC transactions, we'll use this type.	3✔
396	if hasFeatures(local, remote, lnwire.AnchorsZeroFeeHtlcTxOptional) {	6✔
397	chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(	3✔
398	lnwire.AnchorsZeroFeeHtlcTxRequired,	3✔
399	lnwire.StaticRemoteKeyRequired,	3✔
400	))	3✔
401		3✔
402	return &chanType, lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx	3✔
403	}	3✔
404
405	// Since we don't want to support the "legacy" anchor type, we will fall
406	// back to static remote key if the nodes don't support the zero fee
407	// HTLC tx anchor type.
408	//
409	// If both nodes are signaling the proper feature bit for tweakless
410	// commitments, we'll use that.
411	if hasFeatures(local, remote, lnwire.StaticRemoteKeyOptional) {	6✔
412	chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(	3✔
413	lnwire.StaticRemoteKeyRequired,	3✔
414	))	3✔
415		3✔
416	return &chanType, lnwallet.CommitmentTypeTweakless	3✔
417	}	3✔
418
419	// Otherwise we'll fall back to the legacy type.
UNCOV 420	chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector())	×
UNCOV 421	return &chanType, lnwallet.CommitmentTypeLegacy	×
422	}
423
424	// hasFeatures determines whether a set of features is supported by both the set
425	// of local and remote features.
426	func hasFeatures(local, remote *lnwire.FeatureVector,
427	features ...lnwire.FeatureBit) bool {	3✔
428		3✔
429	for _, feature := range features {	6✔
430	if !local.HasFeature(feature) \|\| !remote.HasFeature(feature) {	6✔
431	return false	3✔
432	}	3✔
433	}
434	return true	3✔
435	}

lightningnetwork / lnd / 15561477203

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