loopout: re-target sweep's feerate every block

Add type loopOutSweepFeerateProvider which uses new sweeper package
(SweepFeeProvider), configures it with the constants of loopout.go
(DefaultSweepConfTargetDelta, urgentSweepConfTarget, etc) and provides
fee rate (and confTarget, used only in tests) for a swap. Fee rate is plugged
into sweepbatcher using WithCustomFeeRate.

Added new constants to loopout.go: highPrioSweepAmount, highPrioFeePPM,
urgentSweepConfTarget, urgentSweepConfTargetFactor. The value of
DefaultSweepConfTargetDelta to 10. Previous value was 18. The variable sets the
number of blocks until expiry, when aggressive mode enables. 18 is too early.

Every block 100 sats/kw fee bump is disabled. Sweepbatcher re-targets feerate
every block according to current mempool conditions and the number of blocks
until expiry. If the swap is not of high priority (large amount) and isn't
expiring soon (within DefaultSweepConfTargetDelta blocks), then confTarget
is relative to cltvExpiry.

Added tests for loopOutSweepFeerateProvider simulating various conditions.

Author: starius

client.go

@@ -185,13 +185,45 @@ func NewClient(dbDir string, loopDB loopdb.SwapStore,
 			"NewSweepFetcherFromSwapStore failed: %w", err)
 	}
 
+	// There is circular dependency between executor and sweepbatcher, as
+	// executor stores sweepbatcher and sweepbatcher depends on
+	// executor.height() though loopOutSweepFeerateProvider.
+	var executor *executor
+
+	// getHeight returns current height, according to executor.
+	getHeight := func() int32 {
+		if executor == nil {
+			// This must not happen, because executor is set in this
+			// function, before sweepbatcher.Run is called.
+			log.Errorf("getHeight called when executor is nil")
+
+			return 0
+		}
+
+		return executor.height()
+	}
+
+	loopOutSweepFeerateProvider, err := newLoopOutSweepFeerateProvider(
+		sweeper, loopDB, cfg.Lnd.ChainParams, getHeight,
+	)
+	if err != nil {
+		return nil, nil, fmt.Errorf("newLoopOutSweepFeerateProvider "+
+			"failed: %w", err)
+	}
+
 	batcher := sweepbatcher.NewBatcher(
 		cfg.Lnd.WalletKit, cfg.Lnd.ChainNotifier, cfg.Lnd.Signer,
 		swapServerClient.MultiMuSig2SignSweep, verifySchnorrSig,
 		cfg.Lnd.ChainParams, sweeperDb, sweepStore,
+
+		// Disable 100 sats/kw fee bump every block and retarget feerate
+		// every block according to the current mempool condition.
+		sweepbatcher.WithCustomFeeRate(
+			loopOutSweepFeerateProvider.GetMinFeeRate,
+		),
 	)
 
-	executor := newExecutor(&executorConfig{
+	executor = newExecutor(&executorConfig{
 		lnd:                 cfg.Lnd,
 		store:               loopDB,
 		sweeper:             sweeper,

loopout.go

@@ -52,11 +52,32 @@ const (
 	DefaultHtlcConfTarget = 6
 
 	// DefaultSweepConfTargetDelta is the delta of blocks from a Loop Out
-	// swap's expiration height at which we begin to use the default sweep
-	// confirmation target.
-	//
-	// TODO(wilmer): tune?
-	DefaultSweepConfTargetDelta = DefaultSweepConfTarget * 2
+	// swap's expiration height at which we begin to cap sweep confirmation
+	// target with urgentSweepConfTarget and multiply feerate by factor
+	// urgentSweepConfTargetFactor.
+	DefaultSweepConfTargetDelta = 10
+
+	// urgentSweepConfTarget is the confirmation target we'll use when the
+	// loop-out swap is about to expire (<= DefaultSweepConfTargetDelta
+	// blocks to expire).
+	urgentSweepConfTarget = 3
+
+	// urgentSweepConfTargetFactor is the factor we apply to fee-rate of
+	// loop-out sweep if it is about to expire.
+	urgentSweepConfTargetFactor = 1.1
+
+	// highPrioSweepAmount is a threshold at which a swap is prioritized to
+	// be swept with a fee that is related to its size. The fee amount is
+	// determined by highPrioFeePPM. Current values correspond to 1 BTC
+	// and 0.05% proportional fee.
+	highPrioSweepAmount = 100_000_000
+
+	// highPrioFeePPM expresses the fraction of the swap amount that is paid
+	// towards sweeping fees. This fee is only supposed to be paid for swaps
+	// greater or equal the size of highPrioSwapAmount to expedite the
+	// availability of on-chain funds to generate revenue on loop-out
+	// operations.
+	highPrioFeePPM = 50
 )
 
 // loopOutSwap contains all the in-memory state related to a pending loop out

loopout_feerate.go

@@ -0,0 +1,167 @@
+package loop
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/lightninglabs/loop/loopdb"
+	"github.com/lightninglabs/loop/swap"
+	sweeperpkg "github.com/lightninglabs/loop/sweeper"
+	"github.com/lightninglabs/loop/utils"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
+)
+
+// sweepFeeGetter calculates sweep's confTarget and fee in sats.
+type sweepFeeGetter interface {
+	// SweepFeeRate calculates sweep's confTarget and fee in sats.
+	// It takes high priority case into account.
+	SweepFeeRate(ctx context.Context, amt btcutil.Amount,
+		addInputToEstimator func(e *input.TxWeightEstimator) error,
+		destAddr btcutil.Address, cltvExpiry, height int32,
+		label string) (int32, btcutil.Amount, chainfee.SatPerKWeight,
+		lntypes.WeightUnit, error)
+}
+
+// loopOutFetcher provides the loop out swap with the given hash.
+type loopOutFetcher interface {
+	// FetchLoopOutSwap returns the loop out swap with the given hash.
+	FetchLoopOutSwap(ctx context.Context,
+		hash lntypes.Hash) (*loopdb.LoopOut, error)
+}
+
+// heightGetter returns current height known to the swap server.
+type heightGetter func() int32
+
+// loopOutSweepFeerateProvider provides sweepbatcher with the info about swap's
+// current feerate for loop-out sweep.
+type loopOutSweepFeerateProvider struct {
+	// sweepFeeGetter incorporates the logic of determining swap feerate.
+	sweepFeeGetter sweepFeeGetter
+
+	// loopOutFetcher loads LoopOut from DB by swap hash.
+	loopOutFetcher loopOutFetcher
+
+	// chainParams are the chain parameters of the chain that is used by
+	// swaps.
+	chainParams *chaincfg.Params
+
+	// getHeight returns current height known to the swap server.
+	getHeight heightGetter
+}
+
+// newLoopOutSweepFeerateProvider builds and returns new instance of
+// loopOutSweepFeerateProvider.
+func newLoopOutSweepFeerateProvider(sweeper sweeperpkg.Sweeper,
+	loopOutFetcher loopOutFetcher, chainParams *chaincfg.Params,
+	getHeight heightGetter) (*loopOutSweepFeerateProvider, error) {
+
+	// Initialize sweep fee provider for loop-out's.
+	sweepFeeProvider := &sweeperpkg.SweepFeeProvider{
+		Sweeper: sweeper,
+
+		DefaultSweepConfTargetDelta:  DefaultSweepConfTargetDelta,
+		UrgentSweepConfTarget:        urgentSweepConfTarget,
+		DefaultSweepConfTargetFactor: 1.0,
+		UrgentSweepConfTargetFactor:  urgentSweepConfTargetFactor,
+		HighPrioSweepAmount:          highPrioSweepAmount,
+		HighPrioFeePPM:               highPrioFeePPM,
+	}
+
+	if err := sweepFeeProvider.Validate(); err != nil {
+		return nil, fmt.Errorf("sweep fee provider failed: %w", err)
+	}
+
+	return &loopOutSweepFeerateProvider{
+		sweepFeeGetter: sweepFeeProvider,
+		loopOutFetcher: loopOutFetcher,
+		chainParams:    chainParams,
+		getHeight:      getHeight,
+	}, nil
+}
+
+// GetMinFeeRate returns minimum required feerate for a sweep by swap hash.
+func (p *loopOutSweepFeerateProvider) GetMinFeeRate(ctx context.Context,
+	swapHash lntypes.Hash) (chainfee.SatPerKWeight, error) {
+
+	_, feeRate, err := p.GetConfTargetAndFeeRate(ctx, swapHash)
+
+	return feeRate, err
+}
+
+// GetConfTargetAndFeeRate returns conf target and minimum required feerate
+// for a sweep by swap hash.
+func (p *loopOutSweepFeerateProvider) GetConfTargetAndFeeRate(
+	ctx context.Context, swapHash lntypes.Hash) (int32,
+	chainfee.SatPerKWeight, error) {
+
+	// Load the loop-out from DB.
+	loopOut, err := p.loopOutFetcher.FetchLoopOutSwap(ctx, swapHash)
+	if err != nil {
+		return 0, 0, fmt.Errorf("failed to load swap %x from DB: %w",
+			swapHash[:6], err)
+	}
+
+	contract := loopOut.Contract
+	if contract == nil {
+		return 0, 0, fmt.Errorf("loop-out %x has nil Contract",
+			swapHash[:6])
+	}
+
+	// Determine if we can keyspend.
+	htlcVersion := utils.GetHtlcScriptVersion(contract.ProtocolVersion)
+	canKeyspend := htlcVersion >= swap.HtlcV3
+
+	// Find addInputToEstimator function.
+	var addInputToEstimator func(e *input.TxWeightEstimator) error
+	if canKeyspend {
+		// Assume the server is cooperative and we produce keyspend.
+		addInputToEstimator = func(e *input.TxWeightEstimator) error {
+			e.AddTaprootKeySpendInput(txscript.SigHashDefault)
+			return nil
+		}
+	} else {
+		// Get the HTLC script for our swap.
+		htlc, err := utils.GetHtlc(
+			swapHash, &contract.SwapContract, p.chainParams,
+		)
+		if err != nil {
+			return 0, 0, fmt.Errorf("failed to get HTLC: %w", err)
+		}
+		addInputToEstimator = htlc.AddSuccessToEstimator
+	}
+
+	// Transaction weight might be important for feeRate, in case of high
+	// priority proportional fee, so we accurately assess the size of input.
+	// The size of output is almost the same for all types, so use P2TR.
+	var destAddr *btcutil.AddressTaproot
+
+	// Get current height.
+	height := p.getHeight()
+	if height == 0 {
+		return 0, 0, fmt.Errorf("got zero best block height")
+	}
+
+	// Construct the label.
+	label := fmt.Sprintf("loopout-sweep-%x", swapHash[:6])
+
+	// Estimate confTarget and feeRate.
+	confTarget, _, feeRate, _, err := p.sweepFeeGetter.SweepFeeRate(
+		ctx, contract.AmountRequested, addInputToEstimator, destAddr,
+		contract.CltvExpiry, height, label,
+	)
+	if err != nil {
+		return 0, 0, fmt.Errorf("failed to determine "+
+			"confTarget and feeRate for swap hash %x: %w",
+			swapHash[:6], err)
+	}
+
+	log.Debugf("Estimated for swap %x: feeRate=%s, confTarget=%d.",
+		swapHash[:6], feeRate, confTarget)
+
+	return confTarget, feeRate, nil
+}