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

@@ -40,7 +40,7 @@ func (f *FSM) PublishDepositExpirySweepAction(_ fsm.EventContext) fsm.EventType
 	)
 	if err != nil {
 		return f.HandleError(fmt.Errorf("timeout sweep fee "+
-			"estimation failed: %v", err))
+			"estimation failed: %w", err))
 	}
 
 	weight := script.ExpirySpendWeight()
@@ -95,7 +95,7 @@ func (f *FSM) PublishDepositExpirySweepAction(_ fsm.EventContext) fsm.EventType
 	err = f.cfg.WalletKit.PublishTransaction(f.ctx, msgTx, txLabel)
 	if err != nil {
 		if !strings.Contains(err.Error(), "output already spent") {
-			log.Errorf("%v: %v", txLabel, err)
+			log.Errorf("%v: %w", txLabel, err)
 			f.LastActionError = err
 			return fsm.OnError
 		}
@@ -120,7 +120,7 @@ func (f *FSM) WaitForExpirySweepAction(_ fsm.EventContext) fsm.EventType {
 
 	select {
 	case err := <-errSpendChan:
-		log.Debugf("error while sweeping expired deposit: %v", err)
+		log.Debugf("error while sweeping expired deposit: %w", err)
 		return fsm.OnError
 
 	case confirmedTx := <-spendChan:
@@ -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

@@ -59,47 +59,26 @@ type Deposit struct {
 	sync.Mutex
 }
 
-// IsInPendingState returns true if the deposit is pending.
-func (d *Deposit) IsInPendingState() bool {
-	d.Lock()
-	defer d.Unlock()
-
-	return !d.IsInFinalState()
-}
-
 // IsInFinalState returns true if the deposit is final.
 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 {
-	d.Lock()
-	defer d.Unlock()
-
 	return currentHeight >= uint32(d.ConfirmationHeight)+expiry
 }
 
 func (d *Deposit) GetState() fsm.StateType {
-	d.Lock()
-	defer d.Unlock()
-
 	return d.state
 }
 
 func (d *Deposit) SetState(state fsm.StateType) {
-	d.Lock()
-	defer d.Unlock()
-
 	d.state = state
 }
 
 func (d *Deposit) IsInState(state fsm.StateType) bool {
-	d.Lock()
-	defer d.Unlock()
-
 	return d.state == state
 }
 

staticaddr/deposit/fsm.go

@@ -27,30 +27,95 @@ var (
 
 // States.
 var (
+	// Deposited signals that funds at a static address have reached the
+	// confirmation height.
 	Deposited = fsm.StateType("Deposited")
 
+	// Withdrawing signals that the withdrawal transaction has been
+	// broadcast, awaiting sufficient confirmations.
 	Withdrawing = fsm.StateType("Withdrawing")
 
+	// Withdrawn signals that the withdrawal transaction has been confirmed.
 	Withdrawn = fsm.StateType("Withdrawn")
 
+	// LoopingIn signals that the deposit is locked for a loop in swap.
+	LoopingIn = fsm.StateType("LoopingIn")
+
+	// LoopedIn signals that the loop in swap has been successfully
+	// completed. It implies that we signed the sweepless sweep tx for the
+	// server.
+	LoopedIn = fsm.StateType("LoopedIn")
+
+	// SweepHtlcTimeout signals that the htlc timeout path is in the
+	// process of being swept.
+	SweepHtlcTimeout = fsm.StateType("SweepHtlcTimeout")
+
+	// HtlcTimeoutSwept signals that the htlc timeout path has been swept.
+	HtlcTimeoutSwept = fsm.StateType("HtlcTimeoutSwept")
+
+	// PublishExpiredDeposit signals that the deposit has expired and we are
+	// in the process of publishing the expiry sweep transaction.
 	PublishExpiredDeposit = fsm.StateType("PublishExpiredDeposit")
 
+	// WaitForExpirySweep signals that the expiry sweep transaction has been
+	// published and we are waiting for it to be confirmed.
 	WaitForExpirySweep = fsm.StateType("WaitForExpirySweep")
 
+	// Expired signals that the deposit has expired and the expiry sweep
+	// transaction has been confirmed sufficiently.
 	Expired = fsm.StateType("Expired")
 
+	// Failed signals that the deposit has neither been withdrawn nor looped
+	// in, but expired.
 	Failed = fsm.StateType("Failed")
 )
 
 // Events.
 var (
-	OnStart             = fsm.EventType("OnStart")
+	// OnStart is sent to the fsm once the deposit outpoint has been
+	// sufficiently confirmed. It transitions the fsm into the Deposited
+	// state from where we can trigger a withdrawal, a loopin or an expiry.
+	OnStart = fsm.EventType("OnStart")
+
+	// OnWithdrawInitiated is sent to the fsm when a withdrawal has been
+	// initiated.
 	OnWithdrawInitiated = fsm.EventType("OnWithdrawInitiated")
-	OnWithdrawn         = fsm.EventType("OnWithdrawn")
-	OnExpiry            = fsm.EventType("OnExpiry")
-	OnExpiryPublished   = fsm.EventType("OnExpiryPublished")
-	OnExpirySwept       = fsm.EventType("OnExpirySwept")
-	OnRecover           = fsm.EventType("OnRecover")
+
+	// OnWithdrawn is sent to the fsm when a withdrawal has been confirmed.
+	OnWithdrawn = fsm.EventType("OnWithdrawn")
+
+	// OnLoopinInitiated is sent to the fsm when a loop in has been
+	// initiated.
+	OnLoopinInitiated = fsm.EventType("OnLoopinInitiated")
+
+	// OnSweepingHtlcTimeout is sent to the fsm when the htlc timeout path
+	// is being swept. This indicates that the server didn't pay the swap
+	// invoice, but the htlc tx was published, from we which we need to
+	// sweep the htlc timeout path.
+	OnSweepingHtlcTimeout = fsm.EventType("OnSweepingHtlcTimeout")
+
+	// OnHtlcTimeoutSwept is sent to the fsm when the htlc timeout path has
+	// been swept.
+	OnHtlcTimeoutSwept = fsm.EventType("OnHtlcTimeoutSwept")
+
+	// OnLoopedIn is sent to the fsm when the user intents to use the
+	// deposit for a loop in swap.
+	OnLoopedIn = fsm.EventType("OnLoopedIn")
+
+	// OnExpiry is sent to the fsm when the deposit has expired.
+	OnExpiry = fsm.EventType("OnExpiry")
+
+	// OnExpiryPublished is sent to the fsm when the expiry sweep tx has
+	// been published.
+	OnExpiryPublished = fsm.EventType("OnExpiryPublished")
+
+	// OnExpirySwept is sent to the fsm when the expiry sweep tx has been
+	// confirmed.
+	OnExpirySwept = fsm.EventType("OnExpirySwept")
+
+	// OnRecover is sent to the fsm when it should recover from client
+	// restart.
+	OnRecover = fsm.EventType("OnRecover")
 )
 
 // FSM is the state machine that handles the instant out.
@@ -81,12 +146,12 @@ func NewFSM(ctx context.Context, deposit *Deposit, cfg *ManagerConfig,
 	params, err := cfg.AddressManager.GetStaticAddressParameters(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("unable to get static address "+
-			"parameters: %v", err)
+			"parameters: %w", err)
 	}
 
 	address, err := cfg.AddressManager.GetStaticAddress(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("unable to get static address: %v", err)
+		return nil, fmt.Errorf("unable to get static address: %w", err)
 	}
 
 	depoFsm := &FSM{
@@ -149,7 +214,7 @@ func (f *FSM) handleBlockNotification(currentHeight uint32) {
 				err := f.SendEvent(OnExpiry, nil)
 				if err != nil {
 					log.Debugf("error sending OnExpiry "+
-						"event: %v", err)
+						"event: %w", err)
 				}
 			}()
 		}
@@ -169,6 +234,7 @@ func (f *FSM) DepositStatesV0() fsm.States {
 			Transitions: fsm.Transitions{
 				OnExpiry:            PublishExpiredDeposit,
 				OnWithdrawInitiated: Withdrawing,
+				OnLoopinInitiated:   LoopingIn,
 				OnRecover:           Deposited,
 			},
 			Action: fsm.NoOpAction,
@@ -228,11 +294,55 @@ func (f *FSM) DepositStatesV0() fsm.States {
 			},
 			Action: fsm.NoOpAction,
 		},
+		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.
+				OnSweepingHtlcTimeout: SweepHtlcTimeout,
+
+				OnLoopinInitiated: LoopingIn,
+
+				OnRecover:   LoopingIn,
+				fsm.OnError: Deposited,
+			},
+			Action: fsm.NoOpAction,
+		},
+		LoopedIn: fsm.State{
+			Transitions: fsm.Transitions{
+				OnExpiry: Expired,
+			},
+			Action: f.FinalizeDepositAction,
+		},
+		SweepHtlcTimeout: fsm.State{
+			Transitions: fsm.Transitions{
+				OnHtlcTimeoutSwept: HtlcTimeoutSwept,
+				OnRecover:          SweepHtlcTimeout,
+			},
+			Action: fsm.NoOpAction,
+		},
+		HtlcTimeoutSwept: fsm.State{
+			Transitions: fsm.Transitions{
+				OnExpiry: HtlcTimeoutSwept,
+			},
+			Action: f.FinalizeDepositAction,
+		},
 		Withdrawn: fsm.State{
 			Transitions: fsm.Transitions{
 				OnExpiry: Expired,
 			},
-			Action: f.WithdrawnDepositAction,
+			Action: f.FinalizeDepositAction,
 		},
 		Failed: fsm.State{
 			Transitions: fsm.Transitions{
@@ -256,24 +366,36 @@ 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
 	}
 
 	err := f.cfg.Store.UpdateDeposit(f.ctx, f.deposit)
 	if err != nil {
-		f.Errorf("unable to update deposit: %v", err)
+		f.Errorf("unable to update deposit: %w", err)
 	}
 }
 
+// skipUpdate returns true if the deposit should not be updated for the given
+// notification.
+func skipUpdate(notification fsm.Notification, d *Deposit) bool {
+	prevState := notification.PreviousState
+
+	// 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.
+	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(