lnwallet,funding: simplify initial funding flow

chainreg/chainregistry.go

@@ -154,13 +154,6 @@ const (
 	BtcToLtcConversionRate = 60
 )
 
-// DefaultLtcChannelConstraints is the default set of channel constraints that
-// are meant to be used when initially funding a Litecoin channel.
-var DefaultLtcChannelConstraints = channeldb.ChannelConstraints{
-	DustLimit:        DefaultLitecoinDustLimit,
-	MaxAcceptedHtlcs: input.MaxHTLCNumber / 2,
-}
-
 // PartialChainControl contains all the primary interfaces of the chain control
 // that can be purely constructed from the global configuration. No wallet
 // instance is required for constructing this partial state.
@@ -196,9 +189,9 @@ type PartialChainControl struct {
 	// MinHtlcIn is the minimum HTLC we will accept.
 	MinHtlcIn lnwire.MilliSatoshi
 
-	// ChannelConstraints is the set of default constraints that will be
-	// used for any incoming or outgoing channel reservation requests.
-	ChannelConstraints channeldb.ChannelConstraints
+	// DefaultDustLimit is the default dust limit that will be used for any
+	// incoming or outgoing channel reservation requests.
+	DefaultDustLimit btcutil.Amount
 }
 
 // ChainControl couples the three primary interfaces lnd utilizes for a
@@ -233,17 +226,12 @@ type ChainControl struct {
 	Wallet *lnwallet.LightningWallet
 }
 
-// GenDefaultBtcConstraints generates the default set of channel constraints
-// that are to be used when funding a Bitcoin channel.
-func GenDefaultBtcConstraints() channeldb.ChannelConstraints {
+// GenDefaultBtcDustLimit generates the default dust limit to be used when
+// funding a Bitcoin channel.
+func GenDefaultBtcDustLimit() btcutil.Amount {
 	// We use the dust limit for the maximally sized witness program with
 	// a 40-byte data push.
-	dustLimit := lnwallet.DustLimitForSize(input.UnknownWitnessSize)
-
-	return channeldb.ChannelConstraints{
-		DustLimit:        dustLimit,
-		MaxAcceptedHtlcs: input.MaxHTLCNumber / 2,
-	}
+	return lnwallet.DustLimitForSize(input.UnknownWitnessSize)
 }
 
 // NewPartialChainControl creates a new partial chain control that contains all
@@ -788,9 +776,9 @@ func NewPartialChainControl(cfg *Config) (*PartialChainControl, func(), error) {
 	}
 
 	// Select the default channel constraints for the primary chain.
-	cc.ChannelConstraints = GenDefaultBtcConstraints()
+	cc.DefaultDustLimit = GenDefaultBtcDustLimit()
 	if cfg.PrimaryChain() == LitecoinChain {
-		cc.ChannelConstraints = DefaultLtcChannelConstraints
+		cc.DefaultDustLimit = DefaultLitecoinDustLimit
 	}
 
 	return cc, ccCleanup, nil

config_builder.go

@@ -629,15 +629,15 @@ func (d *DefaultWalletImpl) BuildChainControl(
 	// Create, and start the lnwallet, which handles the core payment
 	// channel logic, and exposes control via proxy state machines.
 	lnWalletConfig := lnwallet.Config{
-		Database:           partialChainControl.Cfg.ChanStateDB,
-		Notifier:           partialChainControl.ChainNotifier,
-		WalletController:   walletController,
-		Signer:             walletController,
-		FeeEstimator:       partialChainControl.FeeEstimator,
-		SecretKeyRing:      keyRing,
-		ChainIO:            walletController,
-		DefaultConstraints: partialChainControl.ChannelConstraints,
-		NetParams:          *walletConfig.NetParams,
+		Database:         partialChainControl.Cfg.ChanStateDB,
+		Notifier:         partialChainControl.ChainNotifier,
+		WalletController: walletController,
+		Signer:           walletController,
+		FeeEstimator:     partialChainControl.FeeEstimator,
+		SecretKeyRing:    keyRing,
+		ChainIO:          walletController,
+		DefaultDustLimit: partialChainControl.DefaultDustLimit,
+		NetParams:        *walletConfig.NetParams,
 	}
 
 	// We've created the wallet configuration now, so we can finish
@@ -717,15 +717,15 @@ func (d *RPCSignerWalletImpl) BuildChainControl(
 	// Create, and start the lnwallet, which handles the core payment
 	// channel logic, and exposes control via proxy state machines.
 	lnWalletConfig := lnwallet.Config{
-		Database:           partialChainControl.Cfg.ChanStateDB,
-		Notifier:           partialChainControl.ChainNotifier,
-		WalletController:   rpcKeyRing,
-		Signer:             rpcKeyRing,
-		FeeEstimator:       partialChainControl.FeeEstimator,
-		SecretKeyRing:      rpcKeyRing,
-		ChainIO:            walletController,
-		DefaultConstraints: partialChainControl.ChannelConstraints,
-		NetParams:          *walletConfig.NetParams,
+		Database:         partialChainControl.Cfg.ChanStateDB,
+		Notifier:         partialChainControl.ChainNotifier,
+		WalletController: rpcKeyRing,
+		Signer:           rpcKeyRing,
+		FeeEstimator:     partialChainControl.FeeEstimator,
+		SecretKeyRing:    rpcKeyRing,
+		ChainIO:          walletController,
+		DefaultDustLimit: partialChainControl.DefaultDustLimit,
+		NetParams:        *walletConfig.NetParams,
 	}
 
 	// We've created the wallet configuration now, so we can finish

docs/release-notes/release-notes-0.16.0.md

@@ -148,6 +148,9 @@ certain large transactions](https://github.com/lightningnetwork/lnd/pull/7100).
   of using a comma separated list of
   values](https://github.com/lightningnetwork/lnd/pull/7207).
 
+* [Fixed a validation bug in `channel_type`
+  negotiation](https://github.com/lightningnetwork/lnd/pull/7177).
+
 ## `lncli`
 
 * [Add an `insecure` flag to skip tls auth as well as a `metadata` string slice
@@ -207,6 +210,9 @@ certain large transactions](https://github.com/lightningnetwork/lnd/pull/7100).
 
 * [Fix loop and other temporary variables being accessed in
   goroutines](https://github.com/lightningnetwork/lnd/pull/7188).
+
+* [Simplify intial funding flow
+  logic](https://github.com/lightningnetwork/lnd/pull/7210).
 
 ## Watchtowers
 

funding/commitment_type_negotiation.go

@@ -8,12 +8,6 @@ import (
 )
 
 var (
-	// errUnsupportedExplicitNegotiation is an error returned when explicit
-	// channel commitment negotiation is attempted but either peer of the
-	// channel does not support it.
-	errUnsupportedExplicitNegotiation = errors.New("explicit channel " +
-		"type negotiation not supported")
-
 	// 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.
@@ -22,37 +16,49 @@ var (
 )
 
 // negotiateCommitmentType negotiates the commitment type of a newly opened
-// channel. If a channelType is provided, explicit negotiation for said type
+// 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. Two booleans are
-// returned letting the caller know if the option-scid-alias or zero-conf
-// channel types were negotiated.
-func negotiateCommitmentType(channelType *lnwire.ChannelType, local,
-	remote *lnwire.FeatureVector, mustBeExplicit bool) (bool,
-	*lnwire.ChannelType, lnwallet.CommitmentType, error) {
-
-	if channelType != nil {
-		// If the peer does know explicit negotiation, let's attempt
-		// that now.
-		if hasFeatures(local, remote, lnwire.ExplicitChannelTypeOptional) {
-			chanType, err := explicitNegotiateCommitmentType(
-				*channelType, local, remote,
+// 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.
+	if hasFeatures(local, remote, lnwire.ExplicitChannelTypeOptional) {
+		if desiredChanType != nil {
+			commitType, err := explicitNegotiateCommitmentType(
+				*desiredChanType, local, remote,
 			)
-			return true, channelType, chanType, err
-		}
 
-		// If we're the funder, and we are attempting to use an
-		// explicit channel type, but the remote party doesn't signal
-		// the bit, then we actually want to exit here, to ensure the
-		// user doesn't end up with an unexpected channel type via
-		// implicit negotiation.
-		if mustBeExplicit {
-			return false, nil, 0, errUnsupportedExplicitNegotiation
+			return desiredChanType, commitType, err
 		}
+
+		// Explicitly signal the "implicit" negotiation commitment type
+		// as default when a desired channel type isn't specified.
+		chanType, commitType := implicitNegotiateCommitmentType(local,
+			remote)
+
+		return chanType, commitType, nil
 	}
 
+	// Otherwise, we'll use implicit negotiation. In this case, we are
+	// restricted to the newest channel type advertised. If the passed-in
+	// channelType doesn't match what was advertised, we fail.
 	chanType, commitType := implicitNegotiateCommitmentType(local, remote)
-	return false, chanType, commitType, nil
+
+	if desiredChanType != nil {
+		expected := lnwire.RawFeatureVector(*desiredChanType)
+		actual := lnwire.RawFeatureVector(*chanType)
+		if !expected.Equals(&actual) {
+			return nil, 0, errUnsupportedChannelType
+		}
+	}
+
+	return nil, commitType, nil
 }
 
 // explicitNegotiateCommitmentType attempts to explicitly negotiate for a