Merge pull request #766 from starius/sweepbatcher-sweep-fetcher

sweepbatcher: factor out loopdb-less version

Author: starius

client.go

@@ -177,10 +177,18 @@ func NewClient(dbDir string, loopDB loopdb.SwapStore,
 		return nil
 	}
 
+	sweepStore, err := sweepbatcher.NewSweepFetcherFromSwapStore(
+		loopDB, cfg.Lnd.ChainParams,
+	)
+	if err != nil {
+		return nil, nil, fmt.Errorf("sweepbatcher."+
+			"NewSweepFetcherFromSwapStore failed: %w", err)
+	}
+
 	batcher := sweepbatcher.NewBatcher(
 		cfg.Lnd.WalletKit, cfg.Lnd.ChainNotifier, cfg.Lnd.Signer,
 		swapServerClient.MultiMuSig2SignSweep, verifySchnorrSig,
-		cfg.Lnd.ChainParams, sweeperDb, loopDB,
+		cfg.Lnd.ChainParams, sweeperDb, sweepStore,
 	)
 
 	executor := newExecutor(&executorConfig{

loopout_test.go

@@ -299,10 +299,15 @@ func testCustomSweepConfTarget(t *testing.T) {
 
 	batcherStore := sweepbatcher.NewStoreMock()
 
+	sweepStore, err := sweepbatcher.NewSweepFetcherFromSwapStore(
+		cfg.store, lnd.ChainParams,
+	)
+	require.NoError(t, err)
+
 	batcher := sweepbatcher.NewBatcher(
 		lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
 		mockMuSig2SignSweep, mockVerifySchnorrSigSuccess,
-		lnd.ChainParams, batcherStore, cfg.store,
+		lnd.ChainParams, batcherStore, sweepStore,
 	)
 
 	tctx, cancel := context.WithCancel(context.Background())
@@ -532,10 +537,15 @@ func testPreimagePush(t *testing.T) {
 
 	batcherStore := sweepbatcher.NewStoreMock()
 
+	sweepStore, err := sweepbatcher.NewSweepFetcherFromSwapStore(
+		cfg.store, lnd.ChainParams,
+	)
+	require.NoError(t, err)
+
 	batcher := sweepbatcher.NewBatcher(
 		lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
 		mockMuSig2SignSweep, mockVerifySchnorrSigSuccess,
-		lnd.ChainParams, batcherStore, cfg.store,
+		lnd.ChainParams, batcherStore, sweepStore,
 	)
 
 	tctx, cancel := context.WithCancel(context.Background())
@@ -953,10 +963,15 @@ func TestLoopOutMuSig2Sweep(t *testing.T) {
 
 	batcherStore := sweepbatcher.NewStoreMock()
 
+	sweepStore, err := sweepbatcher.NewSweepFetcherFromSwapStore(
+		cfg.store, lnd.ChainParams,
+	)
+	require.NoError(t, err)
+
 	batcher := sweepbatcher.NewBatcher(
 		lnd.WalletKit, lnd.ChainNotifier, lnd.Signer,
 		mockMuSig2SignSweep, mockVerifySchnorrSigSuccess,
-		lnd.ChainParams, batcherStore, cfg.store,
+		lnd.ChainParams, batcherStore, sweepStore,
 	)
 
 	tctx, cancel := context.WithCancel(context.Background())

sweepbatcher/sweep_batcher.go

@@ -13,7 +13,9 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop/loopdb"
+	"github.com/lightninglabs/loop/swap"
 	"github.com/lightninglabs/loop/utils"
+	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 )
@@ -82,12 +84,48 @@ type BatcherStore interface {
 	TotalSweptAmount(ctx context.Context, id int32) (btcutil.Amount, error)
 }
 
-// LoopOutFetcher is used to load LoopOut swaps from the database.
-// It is implemented by loopdb.SwapStore.
-type LoopOutFetcher interface {
-	// FetchLoopOutSwap returns the loop out swap with the given hash.
-	FetchLoopOutSwap(ctx context.Context,
-		hash lntypes.Hash) (*loopdb.LoopOut, error)
+// SweepInfo stores any data related to sweeping a specific outpoint.
+type SweepInfo struct {
+	// ConfTarget is the confirmation target of the sweep.
+	ConfTarget int32
+
+	// Timeout is the timeout of the swap that the sweep belongs to.
+	Timeout int32
+
+	// InitiationHeight is the height at which the swap was initiated.
+	InitiationHeight int32
+
+	// HTLC is the HTLC that is being swept.
+	HTLC swap.Htlc
+
+	// Preimage is the preimage of the HTLC that is being swept.
+	Preimage lntypes.Preimage
+
+	// SwapInvoicePaymentAddr is the payment address of the swap invoice.
+	SwapInvoicePaymentAddr [32]byte
+
+	// HTLCKeys is the set of keys used to sign the HTLC.
+	HTLCKeys loopdb.HtlcKeys
+
+	// HTLCSuccessEstimator is a function that estimates the weight of the
+	// HTLC success script.
+	HTLCSuccessEstimator func(*input.TxWeightEstimator) error
+
+	// ProtocolVersion is the protocol version of the swap that the sweep
+	// belongs to.
+	ProtocolVersion loopdb.ProtocolVersion
+
+	// IsExternalAddr is true if the sweep spends to a non-wallet address.
+	IsExternalAddr bool
+
+	// DestAddr is the destination address of the sweep.
+	DestAddr btcutil.Address
+}
+
+// SweepFetcher is used to get details of a sweep.
+type SweepFetcher interface {
+	// FetchSweep returns details of the sweep with the given hash.
+	FetchSweep(ctx context.Context, hash lntypes.Hash) (*SweepInfo, error)
 }
 
 // MuSig2SignSweep is a function that can be used to sign a sweep transaction
@@ -191,8 +229,8 @@ type Batcher struct {
 	// batcher and the batches.
 	store BatcherStore
 
-	// swapStore is used to load LoopOut swaps from the database.
-	swapStore LoopOutFetcher
+	// sweepStore is used to load sweeps from the database.
+	sweepStore SweepFetcher
 
 	// wg is a waitgroup that is used to wait for all the goroutines to
 	// exit.
@@ -204,7 +242,7 @@ func NewBatcher(wallet lndclient.WalletKitClient,
 	chainNotifier lndclient.ChainNotifierClient,
 	signerClient lndclient.SignerClient, musig2ServerSigner MuSig2SignSweep,
 	verifySchnorrSig VerifySchnorrSig, chainparams *chaincfg.Params,
-	store BatcherStore, swapStore LoopOutFetcher) *Batcher {
+	store BatcherStore, sweepStore SweepFetcher) *Batcher {
 
 	return &Batcher{
 		batches:          make(map[int32]*batch),
@@ -219,7 +257,7 @@ func NewBatcher(wallet lndclient.WalletKitClient,
 		VerifySchnorrSig: verifySchnorrSig,
 		chainParams:      chainparams,
 		store:            store,
-		swapStore:        swapStore,
+		sweepStore:       sweepStore,
 	}
 }
 
@@ -661,87 +699,123 @@ func (b *Batcher) writeToErrChan(ctx context.Context, err error) error {
 func (b *Batcher) convertSweep(ctx context.Context, dbSweep *dbSweep) (
 	*sweep, error) {
 
-	swap, err := b.swapStore.FetchLoopOutSwap(ctx, dbSweep.SwapHash)
+	s, err := b.sweepStore.FetchSweep(ctx, dbSweep.SwapHash)
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch loop out for %x: %w",
+		return nil, fmt.Errorf("failed to fetch sweep data for %x: %v",
 			dbSweep.SwapHash[:6], err)
 	}
 
-	htlc, err := utils.GetHtlc(
-		dbSweep.SwapHash, &swap.Contract.SwapContract, b.chainParams,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	swapPaymentAddr, err := utils.ObtainSwapPaymentAddr(
-		swap.Contract.SwapInvoice, b.chainParams,
-	)
-	if err != nil {
-		return nil, err
-	}
-
 	return &sweep{
-		swapHash:               swap.Hash,
+		swapHash:               dbSweep.SwapHash,
 		outpoint:               dbSweep.Outpoint,
 		value:                  dbSweep.Amount,
-		confTarget:             swap.Contract.SweepConfTarget,
-		timeout:                swap.Contract.CltvExpiry,
-		initiationHeight:       swap.Contract.InitiationHeight,
-		htlc:                   *htlc,
-		preimage:               swap.Contract.Preimage,
-		swapInvoicePaymentAddr: *swapPaymentAddr,
-		htlcKeys:               swap.Contract.HtlcKeys,
-		htlcSuccessEstimator:   htlc.AddSuccessToEstimator,
-		protocolVersion:        swap.Contract.ProtocolVersion,
-		isExternalAddr:         swap.Contract.IsExternalAddr,
-		destAddr:               swap.Contract.DestAddr,
+		confTarget:             s.ConfTarget,
+		timeout:                s.Timeout,
+		initiationHeight:       s.InitiationHeight,
+		htlc:                   s.HTLC,
+		preimage:               s.Preimage,
+		swapInvoicePaymentAddr: s.SwapInvoicePaymentAddr,
+		htlcKeys:               s.HTLCKeys,
+		htlcSuccessEstimator:   s.HTLCSuccessEstimator,
+		protocolVersion:        s.ProtocolVersion,
+		isExternalAddr:         s.IsExternalAddr,
+		destAddr:               s.DestAddr,
 	}, nil
 }
 
-// fetchSweep fetches the sweep related information from the database.
-func (b *Batcher) fetchSweep(ctx context.Context,
-	sweepReq SweepRequest) (*sweep, error) {
+// LoopOutFetcher is used to load LoopOut swaps from the database.
+// It is implemented by loopdb.SwapStore.
+type LoopOutFetcher interface {
+	// FetchLoopOutSwap returns the loop out swap with the given hash.
+	FetchLoopOutSwap(ctx context.Context,
+		hash lntypes.Hash) (*loopdb.LoopOut, error)
+}
 
-	swapHash, err := lntypes.MakeHash(sweepReq.SwapHash[:])
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse swapHash: %v", err)
-	}
+// SwapStoreWrapper is LoopOutFetcher wrapper providing SweepFetcher interface.
+type SwapStoreWrapper struct {
+	// swapStore is used to load LoopOut swaps from the database.
+	swapStore LoopOutFetcher
 
-	swap, err := b.swapStore.FetchLoopOutSwap(ctx, swapHash)
+	// chainParams are the chain parameters of the chain that is used by
+	// batches.
+	chainParams *chaincfg.Params
+}
+
+// FetchSweep returns details of the sweep with the given hash.
+// Implements SweepFetcher interface.
+func (f *SwapStoreWrapper) FetchSweep(ctx context.Context,
+	swapHash lntypes.Hash) (*SweepInfo, error) {
+
+	swap, err := f.swapStore.FetchLoopOutSwap(ctx, swapHash)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch loop out for %x: %v",
 			swapHash[:6], err)
 	}
 
 	htlc, err := utils.GetHtlc(
-		swapHash, &swap.Contract.SwapContract, b.chainParams,
+		swapHash, &swap.Contract.SwapContract, f.chainParams,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get htlc: %v", err)
 	}
 
 	swapPaymentAddr, err := utils.ObtainSwapPaymentAddr(
-		swap.Contract.SwapInvoice, b.chainParams,
+		swap.Contract.SwapInvoice, f.chainParams,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get payment addr: %v", err)
 	}
 
+	return &SweepInfo{
+		ConfTarget:             swap.Contract.SweepConfTarget,
+		Timeout:                swap.Contract.CltvExpiry,
+		InitiationHeight:       swap.Contract.InitiationHeight,
+		HTLC:                   *htlc,
+		Preimage:               swap.Contract.Preimage,
+		SwapInvoicePaymentAddr: *swapPaymentAddr,
+		HTLCKeys:               swap.Contract.HtlcKeys,
+		HTLCSuccessEstimator:   htlc.AddSuccessToEstimator,
+		ProtocolVersion:        swap.Contract.ProtocolVersion,
+		IsExternalAddr:         swap.Contract.IsExternalAddr,
+		DestAddr:               swap.Contract.DestAddr,
+	}, nil
+}
+
+// NewSweepFetcherFromSwapStore accepts swapStore (e.g. loopdb) and returns
+// a wrapper implementing SweepFetcher interface (suitable for NewBatcher).
+func NewSweepFetcherFromSwapStore(swapStore LoopOutFetcher,
+	chainParams *chaincfg.Params) (*SwapStoreWrapper, error) {
+
+	return &SwapStoreWrapper{
+		swapStore:   swapStore,
+		chainParams: chainParams,
+	}, nil
+}
+
+// fetchSweep fetches the sweep related information from the database.
+func (b *Batcher) fetchSweep(ctx context.Context,
+	sweepReq SweepRequest) (*sweep, error) {
+
+	s, err := b.sweepStore.FetchSweep(ctx, sweepReq.SwapHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch sweep data for %x: %v",
+			sweepReq.SwapHash[:6], err)
+	}
+
 	return &sweep{
-		swapHash:               swap.Hash,
+		swapHash:               sweepReq.SwapHash,
 		outpoint:               sweepReq.Outpoint,
 		value:                  sweepReq.Value,
-		confTarget:             swap.Contract.SweepConfTarget,
-		timeout:                swap.Contract.CltvExpiry,
-		initiationHeight:       swap.Contract.InitiationHeight,
-		htlc:                   *htlc,
-		preimage:               swap.Contract.Preimage,
-		swapInvoicePaymentAddr: *swapPaymentAddr,
-		htlcKeys:               swap.Contract.HtlcKeys,
-		htlcSuccessEstimator:   htlc.AddSuccessToEstimator,
-		protocolVersion:        swap.Contract.ProtocolVersion,
-		isExternalAddr:         swap.Contract.IsExternalAddr,
-		destAddr:               swap.Contract.DestAddr,
+		confTarget:             s.ConfTarget,
+		timeout:                s.Timeout,
+		initiationHeight:       s.InitiationHeight,
+		htlc:                   s.HTLC,
+		preimage:               s.Preimage,
+		swapInvoicePaymentAddr: s.SwapInvoicePaymentAddr,
+		htlcKeys:               s.HTLCKeys,
+		htlcSuccessEstimator:   s.HTLCSuccessEstimator,
+		protocolVersion:        s.ProtocolVersion,
+		isExternalAddr:         s.IsExternalAddr,
+		destAddr:               s.DestAddr,
 	}, nil
 }