staticaddr: listen for spents on withdrawals

Author: hieblmi

staticaddr/deposit/fsm.go

@@ -361,7 +361,8 @@ func (f *FSM) DepositStatesV0() fsm.States {
 		},
 		Withdrawn: fsm.State{
 			Transitions: fsm.Transitions{
-				OnExpiry: Expired,
+				OnExpiry:    Expired,
+				OnWithdrawn: Withdrawn,
 			},
 			Action: f.FinalizeDepositAction,
 		},

staticaddr/withdraw/manager.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"sync"
 	"sync/atomic"
 
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
@@ -93,6 +94,9 @@ type newWithdrawalResponse struct {
 type Manager struct {
 	cfg *ManagerConfig
 
+	// mu protects access to finalizedWithdrawalTxns.
+	mu sync.Mutex
+
 	// initChan signals the daemon that the withdrawal manager has completed
 	// its initialization.
 	initChan chan struct{}
@@ -243,14 +247,14 @@ func (m *Manager) recoverWithdrawals(ctx context.Context) error {
 			return err
 		}
 
-		err = m.handleWithdrawal(
-			ctx, deposits, tx.TxHash(), tx.TxOut[0].PkScript,
-		)
+		err = m.handleWithdrawal(ctx, deposits, tx.TxHash())
 		if err != nil {
 			return err
 		}
 
+		m.mu.Lock()
 		m.finalizedWithdrawalTxns[tx.TxHash()] = tx
+		m.mu.Unlock()
 	}
 
 	return nil
@@ -275,9 +279,15 @@ func (m *Manager) WithdrawDeposits(ctx context.Context,
 			"withdraw, unconfirmed deposits can't be withdrawn")
 	}
 
+	var (
+		deposits       []*deposit.Deposit
+		allDeposited   bool
+		allWithdrawing bool
+	)
+
 	// Ensure that the deposits are in a state in which they can be
 	// withdrawn.
-	deposits, allDeposited := m.cfg.DepositManager.AllOutpointsActiveDeposits(
+	deposits, allDeposited = m.cfg.DepositManager.AllOutpointsActiveDeposits(
 		outpoints, deposit.Deposited,
 	)
 
@@ -286,7 +296,7 @@ func (m *Manager) WithdrawDeposits(ctx context.Context,
 	// requesting a fee bump, if not we'll return an error as we only allow
 	// fee bumping deposits in state Withdrawing.
 	if !allDeposited {
-		deposits, allWithdrawing := m.cfg.DepositManager.AllOutpointsActiveDeposits(
+		deposits, allWithdrawing = m.cfg.DepositManager.AllOutpointsActiveDeposits(
 			outpoints, deposit.Withdrawing,
 		)
 
@@ -308,6 +318,30 @@ func (m *Manager) WithdrawDeposits(ctx context.Context,
 					"previous withdrawal tx hash")
 			}
 		}
+
+		// We also avoid that the user selects a subset of previously
+		// clustered deposits for a fee bump. This would result in a
+		// different transaction shape.
+		allDeposits, err := m.cfg.DepositManager.GetActiveDepositsInState(
+			deposit.Withdrawing,
+		)
+		if err != nil {
+			return "", "", err
+		}
+
+		allDepositsWithHash := make(map[chainhash.Hash][]*deposit.Deposit)
+		for _, d := range allDeposits {
+			if d.FinalizedWithdrawalTx.TxHash() == hash {
+				allDepositsWithHash[hash] = append(
+					allDepositsWithHash[hash], d,
+				)
+			}
+		}
+
+		if len(allDepositsWithHash[hash]) != len(deposits) {
+			return "", "", fmt.Errorf("can't bump fee for subset " +
+				"of clustered deposits")
+		}
 	}
 
 	var (
@@ -350,27 +384,24 @@ func (m *Manager) WithdrawDeposits(ctx context.Context,
 		return "", "", nil
 	}
 
-	withdrawalPkScript, err := txscript.PayToAddrScript(withdrawalAddress)
-	if err != nil {
-		return "", "", err
-	}
-
-	err = m.handleWithdrawal(
-		ctx, deposits, finalizedTx.TxHash(), withdrawalPkScript,
-	)
+	err = m.handleWithdrawal(ctx, deposits, finalizedTx.TxHash())
 	if err != nil {
 		return "", "", err
 	}
 
 	// If a previous withdrawal existed across the selected deposits, and
-	// it isn't the same as the new withdrawal, we'll stop monitoring the
-	// previous withdrawal and remove it from the finalized withdrawals.
+	// it isn't the same as the new withdrawal, we remove it from the
+	// finalized withdrawals to stop republishing it, but we keep the
+	// goroutine in handleWithdrawal running to monitor the potential
+	// confirmation of the previous withdrawal.
 	deposits[0].Lock()
 	prevTx := deposits[0].FinalizedWithdrawalTx
 	deposits[0].Unlock()
 
 	if prevTx != nil && prevTx.TxHash() != finalizedTx.TxHash() {
+		m.mu.Lock()
 		delete(m.finalizedWithdrawalTxns, prevTx.TxHash())
+		m.mu.Unlock()
 	}
 
 	// Attach the finalized withdrawal tx to the deposits. After a client
@@ -383,7 +414,9 @@ func (m *Manager) WithdrawDeposits(ctx context.Context,
 		d.Unlock()
 	}
 
+	m.mu.Lock()
 	m.finalizedWithdrawalTxns[finalizedTx.TxHash()] = finalizedTx
+	m.mu.Unlock()
 
 	// Transition the deposits to the withdrawing state. This updates each
 	// deposits withdrawal address. If a transition fails, we'll return an
@@ -529,20 +562,36 @@ func (m *Manager) publishFinalizedWithdrawalTx(ctx context.Context,
 }
 
 func (m *Manager) handleWithdrawal(ctx context.Context,
-	deposits []*deposit.Deposit, txHash chainhash.Hash,
-	withdrawalPkScript []byte) error {
+	deposits []*deposit.Deposit, txHash chainhash.Hash) error {
+
+	staticAddress, err := m.cfg.AddressManager.GetStaticAddress(ctx)
+	if err != nil {
+		log.Errorf("error retrieving taproot address %w", err)
+
+		return fmt.Errorf("withdrawal failed")
+	}
 
-	confChan, errChan, err := m.cfg.ChainNotifier.RegisterConfirmationsNtfn(
-		ctx, &txHash, withdrawalPkScript, MinConfs,
-		int32(m.initiationHeight.Load()),
+	address, err := btcutil.NewAddressTaproot(
+		schnorr.SerializePubKey(staticAddress.TaprootKey),
+		m.cfg.ChainParams,
 	)
 	if err != nil {
 		return err
 	}
 
+	script, err := txscript.PayToAddrScript(address)
+	if err != nil {
+		return err
+	}
+
+	d := deposits[0]
+	spentChan, errChan, err := m.cfg.ChainNotifier.RegisterSpendNtfn(
+		ctx, &d.OutPoint, script, int32(d.ConfirmationHeight),
+	)
+
 	go func() {
 		select {
-		case <-confChan:
+		case <-spentChan:
 			err = m.cfg.DepositManager.TransitionDeposits(
 				ctx, deposits, deposit.OnWithdrawn,
 				deposit.Withdrawn,
@@ -552,10 +601,11 @@ func (m *Manager) handleWithdrawal(ctx context.Context,
 					err)
 			}
 
-			// Remove the withdrawal from the active withdrawals and
-			// remove its finalized to stop republishing it on block
-			// arrivals.
+			// Remove the withdrawal tx from the active withdrawals
+			// to stop republishing it on block arrivals.
+			m.mu.Lock()
 			delete(m.finalizedWithdrawalTxns, txHash)
+			m.mu.Unlock()
 
 		case err := <-errChan:
 			log.Errorf("Error waiting for confirmation: %v", err)
@@ -963,7 +1013,14 @@ func (m *Manager) toPrevOuts(deposits []*deposit.Deposit,
 }
 
 func (m *Manager) republishWithdrawals(ctx context.Context) error {
-	for _, finalizedTx := range m.finalizedWithdrawalTxns {
+	m.mu.Lock()
+	txns := make([]*wire.MsgTx, 0, len(m.finalizedWithdrawalTxns))
+	for _, tx := range m.finalizedWithdrawalTxns {
+		txns = append(txns, tx)
+	}
+	m.mu.Unlock()
+
+	for _, finalizedTx := range txns {
 		if finalizedTx == nil {
 			log.Warnf("Finalized withdrawal tx is nil")
 			continue