11219354629

Committed 07 Oct 2024 03:56PM UTC coverage: 58.585% (-0.2%) from 58.814%

Build # 11219354629

Build Type

Pull #9147

github

Committed by

ziggie1984

Commit Message

fixup! sqlc: migration up script for payments.

Pull Request Pull Request #9147: [Part 1|3] Introduce SQL Payment schema into LND

Run Details

130227 of 222287 relevant lines covered (58.59%)

29106.19 hits per line

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

56.03

/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

        // 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) {	129✔
28		129✔
29	// BOLT#2 specifies we MUST use explicit negotiation if both peers	129✔
30	// signal for it.	129✔
31	explicitNegotiation := hasFeatures(	129✔
32	local, remote, lnwire.ExplicitChannelTypeOptional,	129✔
33	)	129✔
34		129✔
35	chanTypeRequested := desiredChanType != nil	129✔
36		129✔
37	switch {	129✔
38	case explicitNegotiation && chanTypeRequested:	25✔
39	commitType, err := explicitNegotiateCommitmentType(	25✔
40	*desiredChanType, local, remote,	25✔
41	)	25✔
42		25✔
43	return desiredChanType, commitType, err	25✔
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:	5✔
49	defaultChanType, commitType := implicitNegotiateCommitmentType(	5✔
50	local, remote,	5✔
51	)	5✔
52		5✔
53	return defaultChanType, commitType, nil	5✔
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.
58	case !explicitNegotiation && chanTypeRequested:	2✔
59	implicitChanType, commitType := implicitNegotiateCommitmentType(	2✔
60	local, remote,	2✔
61	)	2✔
62		2✔
63	expected := lnwire.RawFeatureVector(*desiredChanType)	2✔
64	actual := lnwire.RawFeatureVector(*implicitChanType)	2✔
65	if !expected.Equals(&actual) {	2✔
66	return nil, 0, errUnsupportedChannelType	×
67	}	×
68
69	return nil, commitType, nil	2✔
70
71	default: // !explicitNegotiation && !chanTypeRequested	99✔
72	_, commitType := implicitNegotiateCommitmentType(local, remote)	99✔
73		99✔
74	return nil, commitType, nil	99✔
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) {	25✔
84		25✔
85	channelFeatures := lnwire.RawFeatureVector(channelType)	25✔
86		25✔
87	switch {	25✔
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	):	4✔
136	if !hasFeatures(	4✔
137	local, remote,	4✔
138	lnwire.ZeroConfOptional,	4✔
139	lnwire.ScriptEnforcedLeaseOptional,	4✔
140	lnwire.AnchorsZeroFeeHtlcTxOptional,	4✔
141	lnwire.StaticRemoteKeyOptional,	4✔
142	) {	4✔
143		×
144	return 0, errUnsupportedChannelType	×
145	}	×
146	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	4✔
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	):	6✔
154	if !hasFeatures(	6✔
155	local, remote,	6✔
156	lnwire.ZeroConfOptional,	6✔
157	lnwire.AnchorsZeroFeeHtlcTxOptional,	6✔
158	lnwire.StaticRemoteKeyOptional,	6✔
159	) {	6✔
160		×
161	return 0, errUnsupportedChannelType	×
162	}	×
163	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	6✔
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,
172	):	2✔
173	if !hasFeatures(	2✔
174	local, remote,	2✔
175	lnwire.ScidAliasOptional,	2✔
176	lnwire.ScriptEnforcedLeaseOptional,	2✔
177	lnwire.AnchorsZeroFeeHtlcTxOptional,	2✔
178	lnwire.StaticRemoteKeyOptional,	2✔
179	) {	2✔
180		×
181	return 0, errUnsupportedChannelType	×
182	}	×
183	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	2✔
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	):	4✔
192	if !hasFeatures(	4✔
193	local, remote,	4✔
194	lnwire.ScidAliasOptional,	4✔
195	lnwire.AnchorsZeroFeeHtlcTxOptional,	4✔
196	lnwire.StaticRemoteKeyOptional,	4✔
197	) {	4✔
198		×
199	return 0, errUnsupportedChannelType	×
200	}	×
201	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	4✔
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	):	2✔
210	if !hasFeatures(	2✔
211	local, remote,	2✔
212	lnwire.ScriptEnforcedLeaseOptional,	2✔
213	lnwire.AnchorsZeroFeeHtlcTxOptional,	2✔
214	lnwire.StaticRemoteKeyOptional,	2✔
215	) {	2✔
216		×
217	return 0, errUnsupportedChannelType	×
218	}	×
219	return lnwallet.CommitmentTypeScriptEnforcedLease, nil	2✔
220
221	// Anchors zero fee + static remote key features only.
222	case channelFeatures.OnlyContains(
223	lnwire.AnchorsZeroFeeHtlcTxRequired,
224	lnwire.StaticRemoteKeyRequired,
225	):	7✔
226	if !hasFeatures(	7✔
227	local, remote,	7✔
228	lnwire.AnchorsZeroFeeHtlcTxOptional,	7✔
229	lnwire.StaticRemoteKeyOptional,	7✔
230	) {	9✔
231		2✔
232	return 0, errUnsupportedChannelType	2✔
233	}	2✔
234	return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx, nil	5✔
235
236	// Static remote key feature only.
237	case channelFeatures.OnlyContains(lnwire.StaticRemoteKeyRequired):	4✔
238	if !hasFeatures(local, remote, lnwire.StaticRemoteKeyOptional) {	4✔
239	return 0, errUnsupportedChannelType	×
240	}	×
241	return lnwallet.CommitmentTypeTweakless, nil	4✔
242
243	// Simple taproot channels only.
244	case channelFeatures.OnlyContains(
245	lnwire.SimpleTaprootChannelsRequiredStaging,
246	):	4✔
247		4✔
248	if !hasFeatures(	4✔
249	local, remote,	4✔
250	lnwire.SimpleTaprootChannelsOptionalStaging,	4✔
251	) {	6✔
252		2✔
253	return 0, errUnsupportedChannelType	2✔
254	}	2✔
255
256	return lnwallet.CommitmentTypeSimpleTaproot, nil	4✔
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	):	4✔
280		4✔
281	if !hasFeatures(	4✔
282	local, remote,	4✔
283	lnwire.SimpleTaprootChannelsOptionalStaging,	4✔
284	lnwire.ZeroConfOptional,	4✔
285	) {	4✔
286		×
287	return 0, errUnsupportedChannelType	×
288	}	×
289
290	return lnwallet.CommitmentTypeSimpleTaproot, nil	4✔
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	// No features, use legacy commitment type.
311	case channelFeatures.IsEmpty():
312	return lnwallet.CommitmentTypeLegacy, nil
313		×
314	default:	×
315	return 0, errUnsupportedChannelType	×
316	}	×
317	}	×
318		×
319	// implicitNegotiateCommitmentType negotiates the commitment type of a channel	×
320	// implicitly by choosing the latest type supported by the local and remote	×
321	// features.	×
322	func implicitNegotiateCommitmentType(local,
323	remote lnwire.FeatureVector) (lnwire.ChannelType,	×
324	lnwallet.CommitmentType) {
325
326	// If both peers are signalling support for anchor commitments with
327	// zero-fee HTLC transactions, we'll use this type.
328	if hasFeatures(local, remote, lnwire.AnchorsZeroFeeHtlcTxOptional) {
329	chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(	×
330	lnwire.AnchorsZeroFeeHtlcTxRequired,	×
331	lnwire.StaticRemoteKeyRequired,	×
332	))	×
333		×
334	return &chanType, lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx	×
335	}	×
336		×
337	// Since we don't want to support the "legacy" anchor type, we will fall	×
338	// back to static remote key if the nodes don't support the zero fee	×
339	// HTLC tx anchor type.
340	//	×
341	// If both nodes are signaling the proper feature bit for tweakless
342	// commitments, we'll use that.
343	if hasFeatures(local, remote, lnwire.StaticRemoteKeyOptional) {
344	chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(
345	lnwire.StaticRemoteKeyRequired,
346	))	×
347		×
348	return &chanType, lnwallet.CommitmentTypeTweakless	×
349	}	×
350		×
351	// Otherwise we'll fall back to the legacy type.	×
352	chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector())	×
353	return &chanType, lnwallet.CommitmentTypeLegacy	×
354	}	×
355		×
356	// hasFeatures determines whether a set of features is supported by both the set
357	// of local and remote features.	×
358	func hasFeatures(local, remote *lnwire.FeatureVector,
359	features ...lnwire.FeatureBit) bool {
360
361	for _, feature := range features {
362	if !local.HasFeature(feature) \|\| !remote.HasFeature(feature) {
363	return false
364	}	×
365	}	×
366	return true	×
367	}	×

lightningnetwork / lnd / 11219354629

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