sweepbatcher: consider min relay fee when constructing batch tx

if constructUnsignedTx constructs a batch transaction that is
below the minimum relay fee, an error is returned.

Author: hieblmi

loopout_test.go

@@ -280,6 +280,7 @@ func testCustomSweepConfTarget(t *testing.T) {
 	// yields a much higher fee rate.
 	ctx.Lnd.SetFeeEstimate(testReq.SweepConfTarget, 250)
 	ctx.Lnd.SetFeeEstimate(DefaultSweepConfTarget, 10000)
+	ctx.Lnd.SetMinRelayFee(250)
 
 	cfg := newSwapConfig(
 		&lnd.LndServices, loopdb.NewStoreMock(t), server, nil,

sweepbatcher/presigned.go

@@ -28,8 +28,14 @@ func (b *batch) ensurePresigned(ctx context.Context, newSweeps []*sweep,
 			"adding to an empty batch")
 	}
 
+	minRelayFeeRate, err := b.wallet.MinRelayFee(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get minRelayFee: %w", err)
+	}
+
 	return ensurePresigned(
-		ctx, newSweeps, b.cfg.presignedHelper, b.cfg.chainParams,
+		ctx, newSweeps, b.cfg.presignedHelper, minRelayFeeRate,
+		b.cfg.chainParams,
 	)
 }
 
@@ -43,6 +49,7 @@ type presignedTxChecker interface {
 // inputs of this group only.
 func ensurePresigned(ctx context.Context, newSweeps []*sweep,
 	presignedTxChecker presignedTxChecker,
+	minRelayFeeRate chainfee.SatPerKWeight,
 	chainParams *chaincfg.Params) error {
 
 	sweeps := make([]sweep, len(newSweeps))
@@ -74,7 +81,7 @@ func ensurePresigned(ctx context.Context, newSweeps []*sweep,
 	const feeRate = chainfee.FeePerKwFloor
 
 	tx, _, _, _, err := constructUnsignedTx(
-		sweeps, destAddr, currentHeight, feeRate,
+		sweeps, destAddr, currentHeight, feeRate, minRelayFeeRate,
 	)
 	if err != nil {
 		return fmt.Errorf("failed to construct unsigned tx "+
@@ -218,6 +225,14 @@ func (b *batch) presign(ctx context.Context, newSweeps []*sweep) error {
 
 	b.Infof("nextBlockFeeRate is %v", nextBlockFeeRate)
 
+	// Find the minRelayFeeRate.
+	minRelayFeeRate, err := b.wallet.MinRelayFee(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get minRelayFeeRate: %w", err)
+	}
+
+	b.Infof("minRelayFeeRate is %v", minRelayFeeRate)
+
 	// We need to restore previously added groups. We can do it by reading
 	// all the sweeps from DB (they must be ordered) and grouping by swap.
 	groups, err := b.getSweepsGroups(ctx)
@@ -258,7 +273,7 @@ func (b *batch) presign(ctx context.Context, newSweeps []*sweep) error {
 
 		err = presign(
 			ctx, b.cfg.presignedHelper, destAddr, primarySweepID,
-			sweeps, nextBlockFeeRate,
+			sweeps, nextBlockFeeRate, minRelayFeeRate,
 		)
 		if err != nil {
 			return fmt.Errorf("failed to presign a transaction "+
@@ -300,7 +315,8 @@ type presigner interface {
 // 10x of the current next block feerate.
 func presign(ctx context.Context, presigner presigner, destAddr btcutil.Address,
 	primarySweepID wire.OutPoint, sweeps []sweep,
-	nextBlockFeeRate chainfee.SatPerKWeight) error {
+	nextBlockFeeRate chainfee.SatPerKWeight,
+	minRelayFeeRate chainfee.SatPerKWeight) error {
 
 	if presigner == nil {
 		return fmt.Errorf("presigner is not installed")
@@ -354,7 +370,7 @@ func presign(ctx context.Context, presigner presigner, destAddr btcutil.Address,
 	for fr := start; fr <= stop; fr = (fr * factorPPM) / 1_000_000 {
 		// Construct an unsigned transaction for this fee rate.
 		tx, _, feeForWeight, fee, err := constructUnsignedTx(
-			sweeps, destAddr, currentHeight, fr,
+			sweeps, destAddr, currentHeight, fr, minRelayFeeRate,
 		)
 		if err != nil {
 			return fmt.Errorf("failed to construct unsigned tx "+
@@ -411,15 +427,15 @@ func (b *batch) publishPresigned(ctx context.Context) (btcutil.Amount, error,
 	}
 
 	// Determine the current minimum relay fee based on our chain backend.
-	minRelayFee, err := b.wallet.MinRelayFee(ctx)
+	minRelayFeeRate, err := b.wallet.MinRelayFee(ctx)
 	if err != nil {
-		return 0, fmt.Errorf("failed to get minRelayFee: %w", err),
+		return 0, fmt.Errorf("failed to get minRelayFeeRate: %w", err),
 			false
 	}
 
 	// Cache current height and desired feerate of the batch.
 	currentHeight := b.currentHeight
-	feeRate := max(b.rbfCache.FeeRate, minRelayFee)
+	feeRate := max(b.rbfCache.FeeRate, minRelayFeeRate)
 
 	// Append this sweep to an array of sweeps. This is needed to keep the
 	// order of sweeps stored, as iterating the sweeps map does not
@@ -441,7 +457,7 @@ func (b *batch) publishPresigned(ctx context.Context) (btcutil.Amount, error,
 
 	// Construct unsigned batch transaction.
 	tx, weight, _, fee, err := constructUnsignedTx(
-		sweeps, address, currentHeight, feeRate,
+		sweeps, address, currentHeight, feeRate, minRelayFeeRate,
 	)
 	if err != nil {
 		return 0, fmt.Errorf("failed to construct tx: %w", err),
@@ -460,7 +476,7 @@ func (b *batch) publishPresigned(ctx context.Context) (btcutil.Amount, error,
 	// Get a pre-signed transaction.
 	const loadOnly = false
 	signedTx, err := b.cfg.presignedHelper.SignTx(
-		ctx, b.primarySweepID, tx, batchAmt, minRelayFee, feeRate,
+		ctx, b.primarySweepID, tx, batchAmt, minRelayFeeRate, feeRate,
 		loadOnly,
 	)
 	if err != nil {
@@ -470,7 +486,7 @@ func (b *batch) publishPresigned(ctx context.Context) (btcutil.Amount, error,
 
 	// Run sanity checks to make sure presignedHelper.SignTx complied with
 	// all the invariants.
-	err = CheckSignedTx(tx, signedTx, batchAmt, minRelayFee)
+	err = CheckSignedTx(tx, signedTx, batchAmt, minRelayFeeRate)
 	if err != nil {
 		return 0, fmt.Errorf("signed tx doesn't correspond the "+
 			"unsigned tx: %w", err), false

sweepbatcher/presigned_test.go

@@ -15,6 +15,10 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const (
+	minRelayFeeRate = chainfee.FeePerKwFloor
+)
+
 // TestOrderedSweeps checks that methods batch.getOrderedSweeps and
 // batch.getSweepsGroups works properly.
 func TestOrderedSweeps(t *testing.T) {
@@ -561,7 +565,7 @@ func TestEnsurePresigned(t *testing.T) {
 			}
 
 			err := ensurePresigned(
-				ctx, tc.sweeps, c,
+				ctx, tc.sweeps, c, minRelayFeeRate,
 				&chaincfg.RegressionNetParams,
 			)
 			switch {
@@ -1010,7 +1014,7 @@ func TestPresign(t *testing.T) {
 			err := presign(
 				ctx, tc.presigner, tc.destAddr,
 				tc.primarySweepID, tc.sweeps,
-				tc.nextBlockFeeRate,
+				tc.nextBlockFeeRate, minRelayFeeRate,
 			)
 			if tc.wantErr != "" {
 				require.Error(t, err)

sweepbatcher/sweep_batch.go

@@ -1245,9 +1245,9 @@ func (b *batch) createPsbt(unsignedTx *wire.MsgTx, sweeps []sweep) ([]byte,
 // outputs. If the main output value is below dust limit this function will
 // return an error.
 func constructUnsignedTx(sweeps []sweep, address btcutil.Address,
-	currentHeight int32, feeRate chainfee.SatPerKWeight) (
-	*wire.MsgTx, lntypes.WeightUnit, btcutil.Amount, btcutil.Amount,
-	error) {
+	currentHeight int32, feeRate chainfee.SatPerKWeight,
+	minRelayFeeRate chainfee.SatPerKWeight) (*wire.MsgTx,
+	lntypes.WeightUnit, btcutil.Amount, btcutil.Amount, error) {
 
 	// Sanity check, there should be at least 1 sweep in this batch.
 	if len(sweeps) == 0 {
@@ -1349,7 +1349,14 @@ func constructUnsignedTx(sweeps []sweep, address btcutil.Address,
 	}
 
 	// Clamp the calculated fee to the max allowed fee amount for the batch.
-	fee := clampBatchFee(feeForWeight, batchAmt-btcutil.Amount(sumChange))
+	fee, err := clampBatchFee(
+		feeForWeight, batchAmt-btcutil.Amount(sumChange),
+		minRelayFeeRate, weight,
+	)
+	if err != nil {
+		return nil, 0, 0, 0, fmt.Errorf("failed to clamp batch "+
+			"fee: %w", err)
+	}
 
 	// Ensure that batch amount exceeds the sum of change outputs and the
 	// fee, and that it is also greater than dust limit for the main
@@ -1465,15 +1472,21 @@ func (b *batch) publishMixedBatch(ctx context.Context) (btcutil.Amount, error,
 	// known in advance to be non-cooperative (nonCoopHint) and not failed
 	// to sign cooperatively in previous rounds (coopFailed). If any of them
 	// fails, the sweep is excluded from all following rounds and another
-	// round is attempted. Otherwise the cycle completes and we sign the
+	// round is attempted. Otherwise, the cycle completes and we sign the
 	// remaining sweeps non-cooperatively.
 	var (
-		tx           *wire.MsgTx
-		weight       lntypes.WeightUnit
-		feeForWeight btcutil.Amount
-		fee          btcutil.Amount
-		coopInputs   int
+		tx              *wire.MsgTx
+		weight          lntypes.WeightUnit
+		feeForWeight    btcutil.Amount
+		fee             btcutil.Amount
+		minRelayFeeRate chainfee.SatPerKWeight
+		coopInputs      int
 	)
+	minRelayFeeRate, err := b.wallet.MinRelayFee(ctx)
+	if err != nil {
+		return 0, fmt.Errorf("failed to get min relay fee: %w", err),
+			false
+	}
 	for attempt := 1; ; attempt++ {
 		b.Infof("Attempt %d of collecting cooperative signatures.",
 			attempt)
@@ -1482,6 +1495,7 @@ func (b *batch) publishMixedBatch(ctx context.Context) (btcutil.Amount, error,
 		var err error
 		tx, weight, feeForWeight, fee, err = constructUnsignedTx(
 			sweeps, address, b.currentHeight, b.rbfCache.FeeRate,
+			minRelayFeeRate,
 		)
 		if err != nil {
 			return 0, fmt.Errorf("failed to construct tx: %w", err),
@@ -1533,7 +1547,7 @@ func (b *batch) publishMixedBatch(ctx context.Context) (btcutil.Amount, error,
 		// If there was any failure of cooperative signing, we need to
 		// update weight estimates (since non-cooperative signing has
 		// larger witness) and hence update the whole transaction and
-		// all the signatures. Otherwise we complete cooperative part.
+		// all the signatures. Otherwise, we complete cooperative part.
 		if !newCoopFailures {
 			break
 		}
@@ -1669,7 +1683,7 @@ func (b *batch) publishMixedBatch(ctx context.Context) (btcutil.Amount, error,
 	}
 
 	// Publish the transaction.
-	err := b.wallet.PublishTransaction(
+	err = b.wallet.PublishTransaction(
 		ctx, tx, b.cfg.txLabeler(b.id),
 	)
 	if err != nil {
@@ -2565,16 +2579,25 @@ func (b *batch) persistSweep(ctx context.Context, sweep sweep,
 
 // clampBatchFee takes the fee amount and total amount of the sweeps in the
 // batch and makes sure the fee is not too high. If the fee is too high, it is
-// clamped to the maximum allowed fee.
-func clampBatchFee(fee btcutil.Amount,
-	totalAmount btcutil.Amount) btcutil.Amount {
+// clamped to the maximum allowed fee. If the clamped fee results in a fee rate
+// below the minimum relay fee, an error is returned.
+func clampBatchFee(fee btcutil.Amount, totalAmount btcutil.Amount,
+	minRelayFeeRate chainfee.SatPerKWeight,
+	weight lntypes.WeightUnit) (btcutil.Amount, error) {
 
 	maxFeeAmount := btcutil.Amount(float64(totalAmount) *
 		maxFeeToSwapAmtRatio)
 
+	clampedFee := fee
 	if fee > maxFeeAmount {
-		return maxFeeAmount
+		clampedFee = maxFeeAmount
+	}
+
+	clampedFeeRate := chainfee.NewSatPerKWeight(clampedFee, weight)
+	if clampedFeeRate < minRelayFeeRate {
+		return 0, fmt.Errorf("clamped fee rate %v is less than "+
+			"minimum relay fee %v", clampedFeeRate, minRelayFeeRate)
 	}
 
-	return fee
+	return clampedFee, nil
 }

sweepbatcher/sweep_batch_test.go

@@ -440,12 +440,13 @@ func TestConstructUnsignedTx(t *testing.T) {
 					change:   change1,
 				},
 			},
-			address:       p2trAddress,
-			currentHeight: 800_000,
-			feeRate:       1,
+			address:         p2trAddress,
+			currentHeight:   800_000,
+			feeRate:         1_000,
+			minRelayFeeRate: 50,
 			wantErr: "batch amount 0.00100294 BTC is <= the sum " +
 				"of change outputs 0.00100000 BTC plus fee " +
-				"0.00000001 BTC and dust limit 0.00000330 BTC",
+				"0.00000058 BTC and dust limit 0.00000330 BTC",
 		},
 
 		{

sweepbatcher/sweep_batcher.go

@@ -736,6 +736,10 @@ func (b *Batcher) PresignSweepsGroup(ctx context.Context, inputs []Input,
 	if err != nil {
 		return fmt.Errorf("failed to get nextBlockFeeRate: %w", err)
 	}
+	minRelayFeeRate, err := b.wallet.MinRelayFee(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get minRelayFeeRate: %w", err)
+	}
 	destPkscript, err := txscript.PayToAddrScript(destAddress)
 	if err != nil {
 		return fmt.Errorf("txscript.PayToAddrScript failed: %w", err)
@@ -763,7 +767,7 @@ func (b *Batcher) PresignSweepsGroup(ctx context.Context, inputs []Input,
 
 	return presign(
 		ctx, b.presignedHelper, destAddress, primarySweepID, sweeps,
-		nextBlockFeeRate,
+		nextBlockFeeRate, minRelayFeeRate,
 	)
 }
 
@@ -818,12 +822,18 @@ func (b *Batcher) AddSweep(ctx context.Context, sweepReq *SweepRequest) error {
 		}
 	}
 
+	minRelayFeeRate, err := b.wallet.MinRelayFee(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get min relay fee: %w", err)
+	}
+
 	// If this is a presigned mode, make sure PresignSweepsGroup was called.
 	// We skip the check for reorg-safely confirmed sweeps, because their
 	// presigned transactions were already cleaned up from the store.
 	if sweep.presigned && !fullyConfirmed {
 		err := ensurePresigned(
-			ctx, sweeps, b.presignedHelper, b.chainParams,
+			ctx, sweeps, b.presignedHelper, minRelayFeeRate,
+			b.chainParams,
 		)
 		if err != nil {
 			return fmt.Errorf("inputs with primarySweep %v were "+