looprpc: expose deposit interfaces to withdrawals

Author: hieblmi

staticaddr/deposit/actions.go

@@ -138,3 +138,19 @@ func (f *FSM) SweptExpiredDepositAction(_ fsm.EventContext) fsm.EventType {
 
 	return fsm.NoOp
 }
+
+// WithdrawnDepositAction is the final action after a withdrawal. It signals to
+// the manager that the deposit has been swept and the FSM can be removed. It
+// also ends the state machine main loop by cancelling its context.
+func (f *FSM) WithdrawnDepositAction(_ fsm.EventContext) fsm.EventType {
+	select {
+	case <-f.ctx.Done():
+		return fsm.OnError
+
+	default:
+		f.finalizedDepositChan <- f.deposit.OutPoint
+		f.ctx.Done()
+	}
+
+	return fsm.NoOp
+}

staticaddr/deposit/deposit.go

@@ -55,7 +55,8 @@ func (d *Deposit) IsPending() bool {
 
 // IsFinal returns true if the deposit is final.
 func (d *Deposit) IsFinal() bool {
-	return d.State == Expired || d.State == Failed
+	return d.State == Withdrawn || d.State == Expired ||
+		d.State == Failed
 }
 
 // GetRandomDepositID generates a random deposit ID.

staticaddr/deposit/fsm.go

@@ -29,6 +29,10 @@ var (
 var (
 	Deposited = fsm.StateType("Deposited")
 
+	Withdrawing = fsm.StateType("Withdrawing")
+
+	Withdrawn = fsm.StateType("Withdrawn")
+
 	PublishExpiredDeposit = fsm.StateType("PublishExpiredDeposit")
 
 	WaitForExpirySweep = fsm.StateType("WaitForExpirySweep")
@@ -41,6 +45,8 @@ var (
 // Events.
 var (
 	OnStart           = fsm.EventType("OnStart")
+	OnWithdraw        = fsm.EventType("OnWithdraw")
+	OnWithdrawn       = fsm.EventType("OnWithdrawn")
 	OnExpiry          = fsm.EventType("OnExpiry")
 	OnExpiryPublished = fsm.EventType("OnExpiryPublished")
 	OnExpirySwept     = fsm.EventType("OnExpirySwept")
@@ -172,8 +178,18 @@ func (f *FSM) DepositStatesV0() fsm.States {
 		},
 		Deposited: fsm.State{
 			Transitions: fsm.Transitions{
-				OnExpiry:  PublishExpiredDeposit,
-				OnRecover: Deposited,
+				OnWithdraw: Withdrawing,
+				OnExpiry:   PublishExpiredDeposit,
+				OnRecover:  Deposited,
+			},
+			Action: fsm.NoOpAction,
+		},
+		Withdrawing: fsm.State{
+			Transitions: fsm.Transitions{
+				OnWithdrawn: Withdrawn,
+				OnRecover:   Deposited,
+				OnExpiry:    PublishExpiredDeposit,
+				fsm.OnError: Deposited,
 			},
 			Action: fsm.NoOpAction,
 		},
@@ -207,6 +223,9 @@ func (f *FSM) DepositStatesV0() fsm.States {
 			},
 			Action: f.SweptExpiredDepositAction,
 		},
+		Withdrawn: fsm.State{
+			Action: f.WithdrawnDepositAction,
+		},
 		Failed: fsm.State{
 			Action: fsm.NoOpAction,
 		},

staticaddr/deposit/manager.go

@@ -11,6 +11,7 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
+	"github.com/lightninglabs/loop/fsm"
 	staticaddressrpc "github.com/lightninglabs/loop/swapserverrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/lightningnetwork/lnd/lnwallet"
@@ -419,3 +420,69 @@ func (m *Manager) finalizeDeposit(outpoint wire.OutPoint) {
 	delete(m.deposits, outpoint)
 	m.Unlock()
 }
+
+// GetActiveOutpoints returns all active outpoints.
+func (m *Manager) GetActiveOutpoints() ([]wire.OutPoint, error) {
+	m.Lock()
+	defer m.Unlock()
+
+	var outpoints []wire.OutPoint
+	for o, _ := range m.activeDeposits {
+		outpoints = append(outpoints, o)
+	}
+
+	return outpoints, nil
+}
+
+// AllDepositsActive checks if all deposits referenced by the outpoints are
+// deposited and active and returns them if so.
+func (m *Manager) AllDepositsActive(outpoints []wire.OutPoint) ([]*Deposit,
+	bool) {
+
+	m.Lock()
+	defer m.Unlock()
+
+	var deposits []*Deposit
+	for _, o := range outpoints {
+		if _, ok := m.activeDeposits[o]; !ok {
+			return nil, false
+		}
+
+		deposit := m.deposits[o]
+		if deposit.State != Deposited {
+			return nil, false
+		}
+
+		deposits = append(deposits, m.deposits[o])
+	}
+
+	return deposits, true
+}
+
+// TransitionDeposits allows a caller to transition a set of deposits to a new
+// state.
+func (m *Manager) TransitionDeposits(outpoints []wire.OutPoint,
+	event fsm.EventType, expectedFinalState fsm.StateType) error {
+
+	for _, o := range outpoints {
+		m.Lock()
+		sm, ok := m.activeDeposits[o]
+		m.Unlock()
+		if !ok {
+			return fmt.Errorf("deposit not found")
+		}
+
+		err := sm.SendEvent(event, nil)
+		if err != nil {
+			return err
+		}
+		err = sm.DefaultObserver.WaitForState(
+			m.runCtx, time.Minute, expectedFinalState,
+		)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}