multi: replace DefaultDustLimit with script-specific DustLimitForSize

This commit updates call-sites to use the proper dust limits for
various script types. This also updates the default dust limit used
in the funding flow to be 354 satoshis instead of 573 satoshis.

lnwallet/chanfunding/coin_select.go

@@ -219,7 +219,7 @@ func CoinSelectSubtractFees(feeRate chainfee.SatPerKWeight, amt,
 
 	// If the the output is too small after subtracting the fee, the coin
 	// selection cannot be performed with an amount this small.
-	if outputAmt <= dustLimit {
+	if outputAmt < dustLimit {
 		return nil, 0, 0, fmt.Errorf("output amount(%v) after "+
 			"subtracting fees(%v) below dust limit(%v)", outputAmt,
 			requiredFeeNoChange, dustLimit)
@@ -233,7 +233,7 @@ func CoinSelectSubtractFees(feeRate chainfee.SatPerKWeight, amt,
 	// If adding a change output leads to both outputs being above
 	// the dust limit, we'll add the change output. Otherwise we'll
 	// go with the no change tx we originally found.
-	if newChange > dustLimit && newOutput > dustLimit {
+	if newChange >= dustLimit && newOutput >= dustLimit {
 		outputAmt = newOutput
 		changeAmt = newChange
 	}

lnwallet/chanfunding/coin_select_test.go

@@ -383,7 +383,7 @@ func TestCoinSelectSubtractFees(t *testing.T) {
 				{
 					TxOut: wire.TxOut{
 						PkScript: p2wkhScript,
-						Value:    int64(fundingFee(feeRate, 1, false) + dustLimit),
+						Value:    int64(fundingFee(feeRate, 1, false) + dustLimit - 1),
 					},
 				},
 			},

lnwallet/chanfunding/wallet_assembler.go

@@ -304,7 +304,7 @@ func (w *WalletAssembler) ProvisionChannel(r *Request) (Intent, error) {
 
 		// Sanity check: The addition of the outputs should not lead to the
 		// creation of dust.
-		if changeAmt != 0 && changeAmt <= w.cfg.DustLimit {
+		if changeAmt != 0 && changeAmt < w.cfg.DustLimit {
 			return fmt.Errorf("change amount(%v) after coin "+
 				"select is below dust limit(%v)", changeAmt,
 				w.cfg.DustLimit)

lnwallet/parameters.go

@@ -1,13 +1,50 @@
 package lnwallet
 
 import (
+	"github.com/btcsuite/btcd/mempool"
+	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
-	"github.com/btcsuite/btcwallet/wallet/txrules"
 	"github.com/lightningnetwork/lnd/input"
 )
 
-// DefaultDustLimit is used to calculate the dust HTLC amount which will be
-// send to other node during funding process.
-func DefaultDustLimit() btcutil.Amount {
-	return txrules.GetDustThreshold(input.P2WSHSize, txrules.DefaultRelayFeePerKb)
+// DustLimitForSize retrieves the dust limit for a given pkscript size. Given
+// the size, it automatically determines whether the script is a witness script
+// or not. It calls btcd's GetDustThreshold method under the hood. It must be
+// called with a proper size parameter or else a panic occurs.
+func DustLimitForSize(scriptSize int) btcutil.Amount {
+	var (
+		dustlimit btcutil.Amount
+		pkscript  []byte
+	)
+
+	// With the size of the script, determine which type of pkscript to
+	// create. This will be used in the call to GetDustThreshold. We pass
+	// in an empty byte slice since the contents of the script itself don't
+	// matter.
+	switch scriptSize {
+	case input.P2WPKHSize:
+		pkscript, _ = input.WitnessPubKeyHash([]byte{})
+
+	case input.P2WSHSize:
+		pkscript, _ = input.WitnessScriptHash([]byte{})
+
+	case input.P2SHSize:
+		pkscript, _ = input.GenerateP2SH([]byte{})
+
+	case input.P2PKHSize:
+		pkscript, _ = input.GenerateP2PKH([]byte{})
+
+	case input.UnknownWitnessSize:
+		pkscript, _ = input.GenerateUnknownWitness()
+
+	default:
+		panic("invalid script size")
+	}
+
+	// Call GetDustThreshold with a TxOut containing the generated
+	// pkscript.
+	txout := &wire.TxOut{PkScript: pkscript}
+	dustlimit = btcutil.Amount(mempool.GetDustThreshold(txout))
+
+	return dustlimit
 }

lnwallet/parameters_test.go

@@ -0,0 +1,56 @@
+package lnwallet
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcutil"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/stretchr/testify/require"
+)
+
+// TestDustLimitForSize tests that we receive the expected dust limits for
+// various script types from btcd's GetDustThreshold function.
+func TestDustLimitForSize(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name          string
+		size          int
+		expectedLimit btcutil.Amount
+	}{
+		{
+			name:          "p2pkh dust limit",
+			size:          input.P2PKHSize,
+			expectedLimit: btcutil.Amount(546),
+		},
+		{
+			name:          "p2sh dust limit",
+			size:          input.P2SHSize,
+			expectedLimit: btcutil.Amount(540),
+		},
+		{
+			name:          "p2wpkh dust limit",
+			size:          input.P2WPKHSize,
+			expectedLimit: btcutil.Amount(294),
+		},
+		{
+			name:          "p2wsh dust limit",
+			size:          input.P2WSHSize,
+			expectedLimit: btcutil.Amount(330),
+		},
+		{
+			name:          "unknown witness limit",
+			size:          input.UnknownWitnessSize,
+			expectedLimit: btcutil.Amount(354),
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			dustlimit := DustLimitForSize(test.size)
+			require.Equal(t, test.expectedLimit, dustlimit)
+		})
+	}
+}

lnwallet/reservation.go

@@ -205,6 +205,9 @@ func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 		feeMSat += 2 * lnwire.NewMSatFromSatoshis(anchorSize)
 	}
 
+	// Used to cut down on verbosity.
+	defaultDust := wallet.Cfg.DefaultConstraints.DustLimit
+
 	// If we're the responder to a single-funder reservation, then we have
 	// no initial balance in the channel unless the remote party is pushing
 	// some funds to us within the first commitment state.
@@ -218,7 +221,7 @@ func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 		if int64(theirBalance) < 0 {
 			return nil, ErrFunderBalanceDust(
 				int64(commitFee), int64(theirBalance.ToSatoshis()),
-				int64(2*DefaultDustLimit()),
+				int64(2*defaultDust),
 			)
 		}
 	} else {
@@ -247,7 +250,7 @@ func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 		if int64(ourBalance) < 0 {
 			return nil, ErrFunderBalanceDust(
 				int64(commitFee), int64(ourBalance),
-				int64(2*DefaultDustLimit()),
+				int64(2*defaultDust),
 			)
 		}
 	}
@@ -257,21 +260,21 @@ func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 	// reject this channel creation request.
 	//
 	// TODO(roasbeef): reject if 30% goes to fees? dust channel
-	if initiator && ourBalance.ToSatoshis() <= 2*DefaultDustLimit() {
+	if initiator && ourBalance.ToSatoshis() <= 2*defaultDust {
 		return nil, ErrFunderBalanceDust(
 			int64(commitFee),
 			int64(ourBalance.ToSatoshis()),
-			int64(2*DefaultDustLimit()),
+			int64(2*defaultDust),
 		)
 	}
 
 	// Similarly we ensure their balance is reasonable if we are not the
 	// initiator.
-	if !initiator && theirBalance.ToSatoshis() <= 2*DefaultDustLimit() {
+	if !initiator && theirBalance.ToSatoshis() <= 2*defaultDust {
 		return nil, ErrFunderBalanceDust(
 			int64(commitFee),
 			int64(theirBalance.ToSatoshis()),
-			int64(2*DefaultDustLimit()),
+			int64(2*defaultDust),
 		)
 	}
 

lnwallet/test/test_interface.go

@@ -446,7 +446,7 @@ func testDualFundingReservationWorkflow(miner *rpctest.Harness,
 	}
 	aliceChanReservation.SetNumConfsRequired(numReqConfs)
 	channelConstraints := &channeldb.ChannelConstraints{
-		DustLimit:        lnwallet.DefaultDustLimit(),
+		DustLimit:        alice.Cfg.DefaultConstraints.DustLimit,
 		ChanReserve:      fundingAmount / 100,
 		MaxPendingAmount: lnwire.NewMSatFromSatoshis(fundingAmount),
 		MinHTLC:          1,
@@ -896,7 +896,7 @@ func testSingleFunderReservationWorkflow(miner *rpctest.Harness,
 	}
 	aliceChanReservation.SetNumConfsRequired(numReqConfs)
 	channelConstraints := &channeldb.ChannelConstraints{
-		DustLimit:        lnwallet.DefaultDustLimit(),
+		DustLimit:        alice.Cfg.DefaultConstraints.DustLimit,
 		ChanReserve:      fundingAmt / 100,
 		MaxPendingAmount: lnwire.NewMSatFromSatoshis(fundingAmt),
 		MinHTLC:          1,

lnwallet/transactions_test.go

@@ -542,16 +542,19 @@ func testSpendValidation(t *testing.T, tweakless bool) {
 		Privkeys: []*btcec.PrivateKey{aliceKeyPriv},
 	}
 
+	// Calculate the dust limit we'll use for the test.
+	dustLimit := DustLimitForSize(input.UnknownWitnessSize)
+
 	aliceChanCfg := &channeldb.ChannelConfig{
 		ChannelConstraints: channeldb.ChannelConstraints{
-			DustLimit: DefaultDustLimit(),
+			DustLimit: dustLimit,
 			CsvDelay:  csvTimeout,
 		},
 	}
 
 	bobChanCfg := &channeldb.ChannelConfig{
 		ChannelConstraints: channeldb.ChannelConstraints{
-			DustLimit: DefaultDustLimit(),
+			DustLimit: dustLimit,
 			CsvDelay:  csvTimeout,
 		},
 	}

lnwallet/wallet.go

@@ -689,12 +689,15 @@ func (l *LightningWallet) handleFundingReserveRequest(req *InitFundingReserveMsg
 	// If no chanFunder was provided, then we'll assume the default
 	// assembler, which is backed by the wallet's internal coin selection.
 	if req.ChanFunder == nil {
+		// We use the P2WSH dust limit since it is larger than the
+		// P2WPKH dust limit and to avoid threading through two
+		// different dust limits.
 		cfg := chanfunding.WalletConfig{
 			CoinSource:       &CoinSource{l},
 			CoinSelectLocker: l,
 			CoinLocker:       l,
 			Signer:           l.Cfg.Signer,
-			DustLimit:        DefaultDustLimit(),
+			DustLimit:        DustLimitForSize(input.P2WSHSize),
 		}
 		req.ChanFunder = chanfunding.NewWalletAssembler(cfg)
 	}