staticaddr: deposit changes to be squashed

These deposit changes will be squashed into
the original commits once merged into staging.

Author: hieblmi

staticaddr/deposit/actions.go

@@ -148,9 +148,9 @@ func (f *FSM) SweptExpiredDepositAction(_ fsm.EventContext) fsm.EventType {
 	return fsm.NoOp
 }
 
-// WithdrawnDepositAction is the final action after a withdrawal. It signals to
+// FinalizeDepositAction is the final action after a withdrawal. It signals to
 // the manager that the deposit has been swept and the FSM can be removed.
-func (f *FSM) WithdrawnDepositAction(_ fsm.EventContext) fsm.EventType {
+func (f *FSM) FinalizeDepositAction(_ fsm.EventContext) fsm.EventType {
 	select {
 	case <-f.ctx.Done():
 		return fsm.OnError

staticaddr/deposit/deposit.go

@@ -72,7 +72,9 @@ func (d *Deposit) IsInFinalState() bool {
 	d.Lock()
 	defer d.Unlock()
 
-	return d.state == Expired || d.state == Withdrawn || d.state == Failed
+	return d.state == Expired || d.state == Withdrawn ||
+		d.state == Failed || d.state == LoopedIn ||
+		d.state == HtlcTimeoutSwept
 }
 
 func (d *Deposit) IsExpired(currentHeight, expiry uint32) bool {

staticaddr/deposit/fsm.go

@@ -33,6 +33,14 @@ var (
 
 	Withdrawn = fsm.StateType("Withdrawn")
 
+	LoopingIn = fsm.StateType("LoopingIn")
+
+	LoopedIn = fsm.StateType("LoopedIn")
+
+	SweepHtlcTimout = fsm.StateType("SweepHtlcTimout")
+
+	HtlcTimeoutSwept = fsm.StateType("HtlcTimeoutSwept")
+
 	PublishExpiredDeposit = fsm.StateType("PublishExpiredDeposit")
 
 	WaitForExpirySweep = fsm.StateType("WaitForExpirySweep")
@@ -44,13 +52,17 @@ var (
 
 // Events.
 var (
-	OnStart             = fsm.EventType("OnStart")
-	OnWithdrawInitiated = fsm.EventType("OnWithdrawInitiated")
-	OnWithdrawn         = fsm.EventType("OnWithdrawn")
-	OnExpiry            = fsm.EventType("OnExpiry")
-	OnExpiryPublished   = fsm.EventType("OnExpiryPublished")
-	OnExpirySwept       = fsm.EventType("OnExpirySwept")
-	OnRecover           = fsm.EventType("OnRecover")
+	OnStart              = fsm.EventType("OnStart")
+	OnWithdrawInitiated  = fsm.EventType("OnWithdrawInitiated")
+	OnWithdrawn          = fsm.EventType("OnWithdrawn")
+	OnLoopinInitiated    = fsm.EventType("OnLoopinInitiated")
+	OnSweepingHtlcTimout = fsm.EventType("OnSweepingHtlcTimout")
+	OnHtlcTimeoutSwept   = fsm.EventType("OnHtlcTimeoutSwept")
+	OnLoopedIn           = fsm.EventType("OnLoopedIn")
+	OnExpiry             = fsm.EventType("OnExpiry")
+	OnExpiryPublished    = fsm.EventType("OnExpiryPublished")
+	OnExpirySwept        = fsm.EventType("OnExpirySwept")
+	OnRecover            = fsm.EventType("OnRecover")
 )
 
 // FSM is the state machine that handles the instant out.
@@ -169,6 +181,7 @@ func (f *FSM) DepositStatesV0() fsm.States {
 			Transitions: fsm.Transitions{
 				OnExpiry:            PublishExpiredDeposit,
 				OnWithdrawInitiated: Withdrawing,
+				OnLoopinInitiated:   LoopingIn,
 				OnRecover:           Deposited,
 			},
 			Action: fsm.NoOpAction,
@@ -232,7 +245,57 @@ func (f *FSM) DepositStatesV0() fsm.States {
 			Transitions: fsm.Transitions{
 				OnExpiry: Expired,
 			},
-			Action: f.WithdrawnDepositAction,
+			Action: f.FinalizeDepositAction,
+		},
+		LoopingIn: fsm.State{
+			Transitions: fsm.Transitions{
+				// This event is triggered when the loop in
+				// payment has been received. We consider the
+				// swap to be completed and transition to a
+				// final state.
+				OnLoopedIn: LoopedIn,
+
+				// If the deposit expires while the loop in is
+				// still pending, we publish the expiry sweep.
+				OnExpiry: PublishExpiredDeposit,
+
+				// We encounter this signal if the server
+				// published the htlc tx without paying us. We
+				// then need to monitor for the timeout path to
+				// open up to sweep it.
+				OnSweepingHtlcTimout: SweepHtlcTimout,
+
+				OnLoopinInitiated: LoopingIn,
+
+				OnRecover:   LoopingIn,
+				fsm.OnError: Deposited,
+			},
+			Action: fsm.NoOpAction,
+		},
+		LoopedIn: fsm.State{
+			Transitions: fsm.Transitions{
+				OnExpiry: Expired,
+			},
+			Action: f.FinalizeDepositAction,
+		},
+		SweepHtlcTimout: fsm.State{
+			Transitions: fsm.Transitions{
+				OnHtlcTimeoutSwept: HtlcTimeoutSwept,
+				OnRecover:          SweepHtlcTimout,
+			},
+			Action: fsm.NoOpAction,
+		},
+		HtlcTimeoutSwept: fsm.State{
+			Transitions: fsm.Transitions{
+				OnExpiry: HtlcTimeoutSwept,
+			},
+			Action: f.FinalizeDepositAction,
+		},
+		Withdrawn: fsm.State{
+			Transitions: fsm.Transitions{
+				OnExpiry: Expired,
+			},
+			Action: f.FinalizeDepositAction,
 		},
 		Failed: fsm.State{
 			Transitions: fsm.Transitions{
@@ -257,14 +320,7 @@ func (f *FSM) updateDeposit(notification fsm.Notification) {
 
 	f.deposit.SetState(notification.NextState)
 
-	// Don't update the deposit if we are in an initial state or if we
-	// are transitioning from an initial state to a failed state.
-	d := f.deposit
-	if d.IsInState(fsm.EmptyState) || d.IsInState(Deposited) ||
-		(notification.PreviousState == Deposited && d.IsInState(
-			Failed,
-		)) {
-
+	if skipUpdate(notification, f.deposit) {
 		return
 	}
 
@@ -274,6 +330,23 @@ func (f *FSM) updateDeposit(notification fsm.Notification) {
 	}
 }
 
+// Don't update the deposit if we are in an initial state or if we are
+// transitioning from an initial state to a failed state.
+func skipUpdate(notification fsm.Notification, d *Deposit) bool {
+	prevState := notification.PreviousState
+	if d.IsInState(fsm.EmptyState) || d.IsInState(Deposited) &&
+		prevState == fsm.EmptyState ||
+		d.IsInState(prevState) ||
+		prevState == Deposited && d.IsInState(Deposited) ||
+		prevState == Deposited && d.IsInState(Failed) ||
+		prevState == LoopingIn && d.IsInState(LoopingIn) {
+
+		return true
+	}
+
+	return false
+}
+
 // Infof logs an info message with the deposit outpoint.
 func (f *FSM) Infof(format string, args ...interface{}) {
 	log.Infof(

staticaddr/deposit/manager.go

@@ -423,7 +423,6 @@ func (m *Manager) startDepositFsm(deposit *Deposit) error {
 func (m *Manager) finalizeDeposit(outpoint wire.OutPoint) {
 	m.Lock()
 	delete(m.activeDeposits, outpoint)
-	delete(m.deposits, outpoint)
 	m.Unlock()
 }
 
@@ -456,7 +455,8 @@ func (m *Manager) GetAllDeposits() ([]*Deposit, error) {
 }
 
 // AllOutpointsActiveDeposits checks if all deposits referenced by the outpoints
-// are active and in the specified state.
+// are active and in the specified state. If fsm.EmptyState is reference as
+// stateFilter all deposits are returned regardless of their state.
 func (m *Manager) AllOutpointsActiveDeposits(outpoints []wire.OutPoint,
 	stateFilter fsm.StateType) ([]*Deposit, bool) {
 
@@ -470,7 +470,8 @@ func (m *Manager) AllOutpointsActiveDeposits(outpoints []wire.OutPoint,
 		}
 
 		deposit := m.deposits[o]
-		if deposit.GetState() != stateFilter {
+		if stateFilter != fsm.EmptyState &&
+			deposit.GetState() != stateFilter {
 			return nil, false
 		}
 
@@ -480,6 +481,22 @@ func (m *Manager) AllOutpointsActiveDeposits(outpoints []wire.OutPoint,
 	return deposits, true
 }
 
+func (m *Manager) AllStringOutpointsActiveDeposits(outpoints []string,
+	stateFilter fsm.StateType) ([]*Deposit, bool) {
+
+	outPoints := make([]wire.OutPoint, len(outpoints))
+	for i, o := range outpoints {
+		op, err := wire.NewOutPointFromString(o)
+		if err != nil {
+			return nil, false
+		}
+
+		outPoints[i] = *op
+	}
+
+	return m.AllOutpointsActiveDeposits(outPoints, stateFilter)
+}
+
 // TransitionDeposits allows a caller to transition a set of deposits to a new
 // state.
 func (m *Manager) TransitionDeposits(deposits []*Deposit, event fsm.EventType,

staticaddr/deposit/sql_store.go

@@ -214,8 +214,3 @@ func (s *SqlStore) toDeposit(row sqlc.Deposit,
 		WithdrawalSweepAddress: row.WithdrawalSweepAddress.String,
 	}, nil
 }
-
-// Close closes the database connection.
-func (s *SqlStore) Close() {
-	s.baseDB.DB.Close()
-}