Merge pull request #694 from bhandras/cost-cleanup

loop: fix the loopout per sweep onchain cost and cleanup server cost calculation (both loopin and loopout)

Author: bhandras

loopdb/sqlc/batch.sql.go

@@ -62,6 +62,29 @@ INSERT INTO sweeps (
         amt = $5,
         completed = $6;
 
+-- name: GetParentBatch :one
+SELECT
+        sweep_batches.*
+FROM
+        sweep_batches
+JOIN
+        sweeps ON sweep_batches.id = sweeps.batch_id
+WHERE
+        sweeps.swap_hash = $1
+AND
+        sweeps.completed = TRUE
+AND   
+        sweep_batches.confirmed = TRUE;
+
+-- name: GetBatchSweptAmount :one
+SELECT
+        SUM(amt) AS total
+FROM
+        sweeps
+WHERE
+        batch_id = $1
+AND
+        completed = TRUE;
 
 -- name: GetBatchSweeps :many
 SELECT

loopdb/sqlc/querier.go

@@ -919,9 +919,7 @@ func (s *loopInSwap) waitForSwapComplete(ctx context.Context,
 			s.log.Infof("Htlc spend by tx: %v",
 				spendDetails.SpenderTxHash)
 
-			err := s.processHtlcSpend(
-				ctx, spendDetails, htlcValue, sweepFee,
-			)
+			err := s.processHtlcSpend(ctx, spendDetails, sweepFee)
 			if err != nil {
 				return err
 			}
@@ -959,8 +957,6 @@ func (s *loopInSwap) waitForSwapComplete(ctx context.Context,
 			switch update.State {
 			// Swap invoice was paid, so update server cost balance.
 			case invpkg.ContractSettled:
-				s.cost.Server -= update.AmtPaid
-
 				// If invoice settlement and htlc spend happen
 				// in the expected order, move the swap to an
 				// intermediate state that indicates that the
@@ -977,6 +973,8 @@ func (s *loopInSwap) waitForSwapComplete(ctx context.Context,
 
 				invoiceFinalized = true
 				htlcKeyRevealed = s.tryPushHtlcKey(ctx)
+				s.cost.Server = s.AmountRequested -
+					update.AmtPaid
 
 			// Canceled invoice has no effect on server cost
 			// balance.
@@ -1023,19 +1021,14 @@ func (s *loopInSwap) tryPushHtlcKey(ctx context.Context) bool {
 }
 
 func (s *loopInSwap) processHtlcSpend(ctx context.Context,
-	spend *chainntnfs.SpendDetail, htlcValue,
-	sweepFee btcutil.Amount) error {
+	spend *chainntnfs.SpendDetail, sweepFee btcutil.Amount) error {
 
 	// Determine the htlc input of the spending tx and inspect the witness
 	// to find out whether a success or a timeout tx spent the htlc.
 	htlcInput := spend.SpendingTx.TxIn[spend.SpenderInputIndex]
 
 	if s.htlc.IsSuccessWitness(htlcInput.Witness) {
 		s.setState(loopdb.StateSuccess)
-
-		// Server swept the htlc. The htlc value can be added to the
-		// server cost balance.
-		s.cost.Server += htlcValue
 	} else {
 		// We needed another on chain tx to sweep the timeout clause,
 		// which we now include in our costs.

loopdb/sqlc/queries/batch.sql

@@ -452,7 +452,8 @@ func (s *loopOutSwap) handlePaymentResult(result paymentResult) error {
 		return nil
 
 	case result.status.State == lnrpc.Payment_SUCCEEDED:
-		s.cost.Server += result.status.Value.ToSatoshis()
+		s.cost.Server += result.status.Value.ToSatoshis() -
+			s.AmountRequested
 		s.cost.Offchain += result.status.Fee.ToSatoshis()
 
 		return nil
@@ -514,7 +515,7 @@ func (s *loopOutSwap) executeSwap(globalCtx context.Context) error {
 	}
 
 	// Try to spend htlc and continue (rbf) until a spend has confirmed.
-	spendTx, err := s.waitForHtlcSpendConfirmedV2(
+	spend, err := s.waitForHtlcSpendConfirmedV2(
 		globalCtx, *htlcOutpoint, htlcValue,
 	)
 	if err != nil {
@@ -523,27 +524,23 @@ func (s *loopOutSwap) executeSwap(globalCtx context.Context) error {
 
 	// If spend details are nil, we resolved the swap without waiting for
 	// its spend, so we can exit.
-	if spendTx == nil {
+	if spend == nil {
 		return nil
 	}
 
 	// Inspect witness stack to see if it is a success transaction. We
 	// don't just try to match with the hash of our sweep tx, because it
 	// may be swept by a different (fee) sweep tx from a previous run.
 	htlcInput, err := swap.GetTxInputByOutpoint(
-		spendTx, htlcOutpoint,
+		spend.Tx, htlcOutpoint,
 	)
 	if err != nil {
 		return err
 	}
 
 	sweepSuccessful := s.htlc.IsSuccessWitness(htlcInput.Witness)
 	if sweepSuccessful {
-		s.cost.Server -= htlcValue
-
-		s.cost.Onchain = htlcValue -
-			btcutil.Amount(spendTx.TxOut[0].Value)
-
+		s.cost.Onchain = spend.OnChainFeePortion
 		s.state = loopdb.StateSuccess
 	} else {
 		s.state = loopdb.StateFailSweepTimeout
@@ -1005,9 +1002,9 @@ func (s *loopOutSwap) waitForConfirmedHtlc(globalCtx context.Context) (
 // sweep or a server revocation tx.
 func (s *loopOutSwap) waitForHtlcSpendConfirmedV2(globalCtx context.Context,
 	htlcOutpoint wire.OutPoint, htlcValue btcutil.Amount) (
-	*wire.MsgTx, error) {
+	*sweepbatcher.SpendDetail, error) {
 
-	spendChan := make(chan *wire.MsgTx)
+	spendChan := make(chan *sweepbatcher.SpendDetail)
 	spendErrChan := make(chan error, 1)
 	quitChan := make(chan bool, 1)
 
@@ -1054,10 +1051,10 @@ func (s *loopOutSwap) waitForHtlcSpendConfirmedV2(globalCtx context.Context,
 	for {
 		select {
 		// Htlc spend, break loop.
-		case spendTx := <-spendChan:
-			s.log.Infof("Htlc spend by tx: %v", spendTx.TxHash())
+		case spend := <-spendChan:
+			s.log.Infof("Htlc spend by tx: %v", spend.Tx.TxHash())
 
-			return spendTx, nil
+			return spend, nil
 
 		// Spend notification error.
 		case err := <-spendErrChan:

loopin.go

@@ -22,9 +22,17 @@ type BaseDB interface {
 	GetBatchSweeps(ctx context.Context, batchID int32) (
 		[]sqlc.GetBatchSweepsRow, error)
 
+	// GetBatchSweptAmount returns the total amount of sats swept by a
+	// (confirmed) batch.
+	GetBatchSweptAmount(ctx context.Context, batchID int32) (int64, error)
+
 	// GetSweepStatus returns true if the sweep has been completed.
 	GetSweepStatus(ctx context.Context, swapHash []byte) (bool, error)
 
+	// GetParentBatch fetches the parent batch of a completed sweep.
+	GetParentBatch(ctx context.Context, swapHash []byte) (sqlc.SweepBatch,
+		error)
+
 	// GetSwapUpdates fetches all the updates for a swap.
 	GetSwapUpdates(ctx context.Context, swapHash []byte) (
 		[]sqlc.SwapUpdate, error)
@@ -148,6 +156,34 @@ func (s *SQLStore) FetchBatchSweeps(ctx context.Context, id int32) (
 	return sweeps, nil
 }
 
+// TotalSweptAmount returns the total amount swept by a (confirmed) batch.
+func (s *SQLStore) TotalSweptAmount(ctx context.Context, id int32) (
+	btcutil.Amount, error) {
+
+	amt, err := s.baseDb.GetBatchSweptAmount(ctx, id)
+	if err != nil {
+		return 0, err
+	}
+
+	return btcutil.Amount(amt), nil
+}
+
+// GetParentBatch fetches the parent batch of a completed sweep.
+func (s *SQLStore) GetParentBatch(ctx context.Context, swapHash lntypes.Hash) (
+	*dbBatch, error) {
+
+	batch, err := s.baseDb.GetParentBatch(ctx, swapHash[:])
+	if err != nil {
+		return nil, err
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return convertBatchRow(batch), nil
+}
+
 // UpsertSweep inserts a sweep into the database, or updates an existing sweep
 // if it already exists.
 func (s *SQLStore) UpsertSweep(ctx context.Context, sweep *dbSweep) error {

loopout.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"sort"
 
+	"github.com/btcsuite/btcd/btcutil"
 	"github.com/lightningnetwork/lnd/lntypes"
 )
 
@@ -123,3 +124,44 @@ func (s *StoreMock) AssertSweepStored(id lntypes.Hash) bool {
 	_, ok := s.sweeps[id]
 	return ok
 }
+
+// GetParentBatch returns the parent batch of a swap.
+func (s *StoreMock) GetParentBatch(ctx context.Context, swapHash lntypes.Hash) (
+	*dbBatch, error) {
+
+	for _, sweep := range s.sweeps {
+		if sweep.SwapHash == swapHash {
+			batch, ok := s.batches[sweep.BatchID]
+			if !ok {
+				return nil, errors.New("batch not found")
+			}
+			return &batch, nil
+		}
+	}
+
+	return nil, errors.New("batch not found")
+}
+
+// TotalSweptAmount returns the total amount of BTC that has been swept from a
+// batch.
+func (s *StoreMock) TotalSweptAmount(ctx context.Context, batchID int32) (
+	btcutil.Amount, error) {
+
+	batch, ok := s.batches[batchID]
+	if !ok {
+		return 0, errors.New("batch not found")
+	}
+
+	if batch.State != batchConfirmed && batch.State != batchClosed {
+		return 0, nil
+	}
+
+	var total btcutil.Amount
+	for _, sweep := range s.sweeps {
+		if sweep.BatchID == batchID {
+			total += sweep.Amount
+		}
+	}
+
+	return 0, nil
+}