[2/5]sweep: refactor fee estimation and introduce UtxoAggregator

contractcourt/commit_sweep_resolver_test.go

@@ -140,8 +140,8 @@ func (s *mockSweeper) SweepInput(input input.Input, params sweep.Params) (
 	return result, nil
 }
 
-func (s *mockSweeper) CreateSweepTx(inputs []input.Input, feePref sweep.FeePreference,
-	currentBlockHeight uint32) (*wire.MsgTx, error) {
+func (s *mockSweeper) CreateSweepTx(inputs []input.Input,
+	feePref sweep.FeePreference) (*wire.MsgTx, error) {
 
 	// We will wait for the test to supply the sweep tx to return.
 	sweepTx := <-s.createSweepTxChan

contractcourt/htlc_success_resolver.go

@@ -432,17 +432,13 @@ func (h *htlcSuccessResolver) resolveRemoteCommitOutput() (
 		// transaction, that we'll use to move these coins back into
 		// the backing wallet.
 		//
-		// TODO: Set tx lock time to current block height instead of
-		// zero. Will be taken care of once sweeper implementation is
-		// complete.
-		//
 		// TODO: Use time-based sweeper and result chan.
 		var err error
 		h.sweepTx, err = h.Sweeper.CreateSweepTx(
 			[]input.Input{inp},
 			sweep.FeePreference{
 				ConfTarget: sweepConfTarget,
-			}, 0,
+			},
 		)
 		if err != nil {
 			return nil, err

contractcourt/interfaces.go

@@ -52,8 +52,8 @@ type UtxoSweeper interface {
 	// CreateSweepTx accepts a list of inputs and signs and generates a txn
 	// that spends from them. This method also makes an accurate fee
 	// estimate before generating the required witnesses.
-	CreateSweepTx(inputs []input.Input, feePref sweep.FeePreference,
-		currentBlockHeight uint32) (*wire.MsgTx, error)
+	CreateSweepTx(inputs []input.Input,
+		feePref sweep.FeePreference) (*wire.MsgTx, error)
 
 	// RelayFeePerKW returns the minimum fee rate required for transactions
 	// to be relayed.

htlcswitch/mock.go

@@ -81,6 +81,7 @@ func (m *mockPreimageCache) SubscribeUpdates(
 	return nil, nil
 }
 
+// TODO(yy): replace it with chainfee.MockEstimator.
 type mockFeeEstimator struct {
 	byteFeeIn chan chainfee.SatPerKWeight
 	relayFee  chan chainfee.SatPerKWeight

lnrpc/rpc_utils.go

@@ -222,12 +222,12 @@ func CalculateFeeRate(satPerByte, satPerVByte uint64, targetConf uint32,
 
 	// Based on the passed fee related parameters, we'll determine an
 	// appropriate fee rate for this transaction.
-	feeRate, err := sweep.DetermineFeePerKw(
-		estimator, sweep.FeePreference{
-			ConfTarget: targetConf,
-			FeeRate:    satPerKw,
-		},
-	)
+	feePref := sweep.FeePreference{
+		ConfTarget: targetConf,
+		FeeRate:    satPerKw,
+	}
+	// TODO(yy): need to pass the configured max fee here.
+	feeRate, err := feePref.Estimate(estimator, 0)
 	if err != nil {
 		return feeRate, err
 	}

lnwallet/chainfee/mocks.go

@@ -1,6 +1,8 @@
 package chainfee
 
-import "github.com/stretchr/testify/mock"
+import (
+	"github.com/stretchr/testify/mock"
+)
 
 type mockFeeSource struct {
 	mock.Mock
@@ -15,3 +17,50 @@ func (m *mockFeeSource) GetFeeMap() (map[uint32]uint32, error) {
 
 	return args.Get(0).(map[uint32]uint32), args.Error(1)
 }
+
+// MockEstimator implements the `Estimator` interface and is used by
+// other packages for mock testing.
+type MockEstimator struct {
+	mock.Mock
+}
+
+// Compile time assertion that MockEstimator implements Estimator.
+var _ Estimator = (*MockEstimator)(nil)
+
+// EstimateFeePerKW takes in a target for the number of blocks until an initial
+// confirmation and returns the estimated fee expressed in sat/kw.
+func (m *MockEstimator) EstimateFeePerKW(
+	numBlocks uint32) (SatPerKWeight, error) {
+
+	args := m.Called(numBlocks)
+
+	if args.Get(0) == nil {
+		return 0, args.Error(1)
+	}
+
+	return args.Get(0).(SatPerKWeight), args.Error(1)
+}
+
+// Start signals the Estimator to start any processes or goroutines it needs to
+// perform its duty.
+func (m *MockEstimator) Start() error {
+	args := m.Called()
+
+	return args.Error(0)
+}
+
+// Stop stops any spawned goroutines and cleans up the resources used by the
+// fee estimator.
+func (m *MockEstimator) Stop() error {
+	args := m.Called()
+
+	return args.Error(0)
+}
+
+// RelayFeePerKW returns the minimum fee rate required for transactions to be
+// relayed. This is also the basis for calculation of the dust limit.
+func (m *MockEstimator) RelayFeePerKW() SatPerKWeight {
+	args := m.Called()
+
+	return args.Get(0).(SatPerKWeight)
+}

rpcserver.go

@@ -1174,11 +1174,13 @@ func (r *rpcServer) EstimateFee(ctx context.Context,
 	// Query the fee estimator for the fee rate for the given confirmation
 	// target.
 	target := in.TargetConf
-	feePerKw, err := sweep.DetermineFeePerKw(
-		r.server.cc.FeeEstimator, sweep.FeePreference{
-			ConfTarget: uint32(target),
-		},
-	)
+	feePref := sweep.FeePreference{
+		ConfTarget: uint32(target),
+	}
+
+	// Since we are providing a fee estimation as an RPC response, there's
+	// no need to set a max feerate here, so we use 0.
+	feePerKw, err := feePref.Estimate(r.server.cc.FeeEstimator, 0)
 	if err != nil {
 		return nil, err
 	}

server.go

@@ -1064,7 +1064,6 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 
 	s.sweeper = sweep.New(&sweep.UtxoSweeperConfig{
 		FeeEstimator:         cc.FeeEstimator,
-		DetermineFeePerKw:    sweep.DetermineFeePerKw,
 		GenSweepScript:       newSweepPkScriptGen(cc.Wallet),
 		Signer:               cc.Wallet.Cfg.Signer,
 		Wallet:               newSweeperWallet(cc.Wallet),

sweep/fee_estimator_mock_test.go

@@ -9,6 +9,8 @@ import (
 // mockFeeEstimator implements a mock fee estimator. It closely resembles
 // lnwallet.StaticFeeEstimator with the addition that fees can be changed for
 // testing purposes in a thread safe manner.
+//
+// TODO(yy): replace it with chainfee.MockEstimator once it's merged.
 type mockFeeEstimator struct {
 	feePerKW chainfee.SatPerKWeight