staticaddr: preserve deposit identity across RBF

When an unconfirmed static-address deposit was replaced, the client reconciler only knew how to mark the original outpoint gone and discover the descendant as a brand-new deposit. That split the logical deposit identity across two records: the old deposit, active FSM and pending loop-in still pointed at the dead outpoint while the replacement surfaced as unrelated new funds.

Teach the deposit manager to rebind uniquely matched unconfirmed replacements in place, carrying the deposit ID, state and active FSM forward to the new outpoint. This keeps looping-in deposits attached to the replacement chain instead of leaving them stranded on the vanished outpoint. Keep the existing vanished-deposit invalidation path for cases that cannot be matched safely.

Also reload static loop-ins from the current deposit rows rather than the stale outpoint snapshot stored at swap creation time, and add targeted tests for replacement rebinding and recovered outpoint loading.

Author: hieblmi

staticaddr/deposit/manager.go

@@ -9,6 +9,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/lndclient"
@@ -307,6 +308,12 @@ func (m *Manager) reconcileDeposits(ctx context.Context) error {
 			err)
 	}
 
+	err = m.reconcileReplacementDeposits(ctx, utxos)
+	if err != nil {
+		return fmt.Errorf("unable to reconcile replacement "+
+			"deposits: %w", err)
+	}
+
 	// After handling reappearances, only still-missing outpoints contribute
 	// towards replacement detection.
 	err = m.invalidateVanishedDeposits(ctx, utxos)
@@ -395,6 +402,139 @@ func (m *Manager) listUnspentWithBestHeight(ctx context.Context) (
 	return nil, 0, errors.New("unable to get stable best block while " +
 		"listing deposits")
 }
+
+// reconcileReplacementDeposits rebinds uniquely matchable unconfirmed
+// deposits to a replacement outpoint when the original outpoint vanished from
+// the wallet's unspent set. This preserves the logical deposit identity across
+// RBF replacements and keeps any attached loop-in state tied to the same
+// deposit record.
+func (m *Manager) reconcileReplacementDeposits(ctx context.Context,
+	utxos []*lnwallet.Utxo) error {
+
+	knownOutpoints := make(map[wire.OutPoint]struct{}, len(utxos))
+	unknownByValue := make(map[btcutil.Amount][]*lnwallet.Utxo)
+
+	m.mu.Lock()
+	for _, utxo := range utxos {
+		knownOutpoints[utxo.OutPoint] = struct{}{}
+
+		if _, ok := m.deposits[utxo.OutPoint]; ok {
+			delete(m.missingDeposits, utxo.OutPoint)
+			continue
+		}
+
+		unknownByValue[utxo.Value] = append(
+			unknownByValue[utxo.Value], utxo,
+		)
+	}
+
+	deposits := make([]*Deposit, 0, len(m.deposits))
+	for _, deposit := range m.deposits {
+		deposits = append(deposits, deposit)
+	}
+	m.mu.Unlock()
+
+	missingByValue := make(map[btcutil.Amount][]*Deposit)
+	for _, deposit := range deposits {
+		if _, ok := knownOutpoints[deposit.OutPoint]; ok {
+			continue
+		}
+
+		deposit.Lock()
+		state := deposit.state
+		unconfirmed := deposit.ConfirmationHeight == 0
+		value := deposit.Value
+		deposit.Unlock()
+
+		if !unconfirmed {
+			continue
+		}
+
+		switch state {
+		case Deposited, LoopingIn:
+		default:
+			continue
+		}
+
+		missingByValue[value] = append(missingByValue[value], deposit)
+	}
+
+	for value, missingDeposits := range missingByValue {
+		replacementUtxos := unknownByValue[value]
+		if len(missingDeposits) != 1 || len(replacementUtxos) != 1 {
+			continue
+		}
+
+		err := m.rebindReplacementDeposit(
+			ctx, missingDeposits[0], replacementUtxos[0],
+		)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// rebindReplacementDeposit moves a deposit's identity from a disappeared
+// outpoint to a replacement wallet UTXO while preserving its state and ID.
+func (m *Manager) rebindReplacementDeposit(ctx context.Context, deposit *Deposit,
+	utxo *lnwallet.Utxo) error {
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	deposit.Lock()
+	defer deposit.Unlock()
+	if deposit.ConfirmationHeight != 0 {
+		return nil
+	}
+
+	switch deposit.state {
+	case Deposited, LoopingIn:
+	default:
+		return nil
+	}
+	confirmationHeight, err := confirmationHeightForUtxo(
+		int32(m.currentHeight.Load()), utxo,
+	)
+	if err != nil {
+		return err
+	}
+
+	oldOutpoint := deposit.OutPoint
+	previousValue := deposit.Value
+	previousConfirmationHeight := deposit.ConfirmationHeight
+
+	deposit.OutPoint = utxo.OutPoint
+	deposit.Value = utxo.Value
+	deposit.ConfirmationHeight = confirmationHeight
+
+	err = m.cfg.Store.UpdateDeposit(ctx, deposit)
+	if err != nil {
+		deposit.OutPoint = oldOutpoint
+		deposit.Value = previousValue
+		deposit.ConfirmationHeight = previousConfirmationHeight
+		return err
+	}
+
+	delete(m.deposits, oldOutpoint)
+	delete(m.missingDeposits, oldOutpoint)
+	delete(m.missingDeposits, deposit.OutPoint)
+	m.deposits[deposit.OutPoint] = deposit
+
+	fsm, ok := m.activeDeposits[oldOutpoint]
+	if ok {
+		delete(m.activeDeposits, oldOutpoint)
+		m.activeDeposits[deposit.OutPoint] = fsm
+	}
+
+	log.Infof("Rebound deposit %x from %v to replacement %v",
+		deposit.ID, oldOutpoint, deposit.OutPoint)
+
+	return nil
+}
+
 // createNewDeposit transforms the wallet utxo into a deposit struct and stores
 // it in our database and manager memory.
 func (m *Manager) createNewDeposit(ctx context.Context,

staticaddr/deposit/manager_rebind_test.go

@@ -0,0 +1,82 @@
+package deposit
+
+import (
+	"context"
+	"testing"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/loop/fsm"
+	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRebindReplacementDepositRevalidatesCandidate(t *testing.T) {
+	ctx := context.Background()
+	oldOutpoint := wire.OutPoint{
+		Hash:  chainhash.Hash{6},
+		Index: 2,
+	}
+	newOutpoint := wire.OutPoint{
+		Hash:  chainhash.Hash{7},
+		Index: 3,
+	}
+
+	testCases := []struct {
+		name               string
+		confirmationHeight int64
+		state              fsm.StateType
+	}{
+		{
+			name:  "final state",
+			state: LoopedIn,
+		},
+		{
+			name:               "confirmed",
+			confirmationHeight: 44,
+			state:              LoopingIn,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			deposit := &Deposit{
+				OutPoint:           oldOutpoint,
+				Value:              btcutil.Amount(50_000),
+				ConfirmationHeight: tc.confirmationHeight,
+			}
+			deposit.SetState(tc.state)
+
+			mockStore := new(mockStore)
+			manager := NewManager(&ManagerConfig{
+				Store: mockStore,
+			})
+			manager.deposits[oldOutpoint] = deposit
+			fsm := &FSM{}
+			manager.activeDeposits[oldOutpoint] = fsm
+			manager.missingDeposits[oldOutpoint] = 1
+
+			err := manager.rebindReplacementDeposit(ctx, deposit,
+				&lnwallet.Utxo{
+					OutPoint: newOutpoint,
+					Value:    deposit.Value,
+				},
+			)
+			require.NoError(t, err)
+
+			require.Same(t, deposit, manager.deposits[oldOutpoint])
+			_, ok := manager.deposits[newOutpoint]
+			require.False(t, ok)
+			require.Same(t, fsm, manager.activeDeposits[oldOutpoint])
+			_, ok = manager.activeDeposits[newOutpoint]
+			require.False(t, ok)
+			require.Equal(t, oldOutpoint, deposit.OutPoint)
+
+			mockStore.AssertNotCalled(
+				t, "UpdateDeposit", mock.Anything, mock.Anything,
+			)
+		})
+	}
+}

staticaddr/deposit/manager_reconcile_test.go

@@ -344,3 +344,76 @@ func TestReconcileDepositsReactivatesReappearedReplacedDeposit(t *testing.T) {
 	require.Zero(t, deposit.ConfirmationHeight)
 	require.Len(t, manager.activeDeposits, 1)
 }
+
+// TestReconcileReplacementDeposit ensures that an unconfirmed deposit keeps its
+// identity when its original funding transaction is replaced.
+func TestReconcileReplacementDeposit(t *testing.T) {
+	ctx := context.Background()
+	oldOutpoint := wire.OutPoint{
+		Hash:  chainhash.Hash{4},
+		Index: 8,
+	}
+	newOutpoint := wire.OutPoint{
+		Hash:  chainhash.Hash{5},
+		Index: 9,
+	}
+
+	depositID, err := GetRandomDepositID()
+	require.NoError(t, err)
+
+	deposit := &Deposit{
+		ID:       depositID,
+		OutPoint: oldOutpoint,
+		Value:    btcutil.Amount(100_000),
+	}
+	deposit.SetState(LoopingIn)
+
+	utxo := &lnwallet.Utxo{
+		OutPoint:      newOutpoint,
+		Value:         deposit.Value,
+		Confirmations: 0,
+	}
+
+	mockAddressManager := new(mockAddressManager)
+	mockAddressManager.On(
+		"ListUnspent", mock.Anything, int32(0), int32(MaxConfs),
+	).Return([]*lnwallet.Utxo{utxo}, nil)
+
+	mockStore := new(mockStore)
+	mockStore.On(
+		"UpdateDeposit", mock.Anything, mock.Anything,
+	).Return(nil).Run(func(args mock.Arguments) {
+		updatedDeposit := args.Get(1).(*Deposit)
+		require.Equal(t, depositID, updatedDeposit.ID)
+		require.Equal(t, newOutpoint, updatedDeposit.OutPoint)
+		require.True(t, updatedDeposit.IsInStateNoLock(LoopingIn))
+	})
+
+	manager := NewManager(&ManagerConfig{
+		AddressManager: mockAddressManager,
+		Store:          mockStore,
+	})
+	manager.deposits[oldOutpoint] = deposit
+	fsm := &FSM{}
+	manager.activeDeposits[oldOutpoint] = fsm
+	manager.missingDeposits[oldOutpoint] = 1
+
+	require.NoError(t, manager.reconcileDeposits(ctx))
+
+	_, ok := manager.deposits[oldOutpoint]
+	require.False(t, ok)
+
+	rebinding, ok := manager.deposits[newOutpoint]
+	require.True(t, ok)
+	require.Same(t, deposit, rebinding)
+	require.Equal(t, newOutpoint, rebinding.OutPoint)
+	require.Equal(t, LoopingIn, rebinding.GetState())
+	require.Zero(t, rebinding.ConfirmationHeight)
+
+	_, ok = manager.activeDeposits[oldOutpoint]
+	require.False(t, ok)
+	require.Same(t, fsm, manager.activeDeposits[newOutpoint])
+
+	_, ok = manager.missingDeposits[oldOutpoint]
+	require.False(t, ok)
+}