staticaddr/loopin: update fsm for server ntfn sigs

This commit updates the loop in FSM to handle the new server based
pulled sweepless sweep sigs.

Author: sputn1ck

staticaddr/loopin/actions.go

@@ -12,7 +12,6 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/txscript"
-	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcwallet/chain"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
@@ -777,102 +776,7 @@ func (f *FSM) PaymentReceivedAction(ctx context.Context,
 		return f.HandleError(err)
 	}
 
-	return OnFetchSignPushSweeplessSweepTx
-}
-
-// FetchSignPushSweeplessSweepTxAction requests server nonces, fee rate and
-// destination address for the sweepless sweep transaction. It then creates the
-// sweep transaction and signs it with the server and client nonces. If signing
-// succeeds it pushes the signatures to the server.
-func (f *FSM) FetchSignPushSweeplessSweepTxAction(ctx context.Context,
-	_ fsm.EventContext) fsm.EventType {
-
-	// Fetch the sweepless sweep tx details from server.
-	fetchReq := &looprpc.FetchSweeplessSweepTxRequest{
-		SwapHash: f.loopIn.SwapHash[:],
-	}
-	fetchResp, err := f.cfg.Server.FetchSweeplessSweepTx(ctx, fetchReq)
-	if err != nil {
-		err = fmt.Errorf("unable to fetch sweepless sweep tx: %w", err)
-
-		return f.HandleError(err)
-	}
-
-	address, err := btcutil.DecodeAddress(
-		fetchResp.SweepAddr, f.cfg.ChainParams,
-	)
-	if err != nil {
-		f.Warnf("unable to decode sweep address: %v", err)
-	}
-
-	clientResponse := make(map[uint64]*looprpc.ClientSweeplessSigningInfo)
-
-	var (
-		nonces              [][]byte
-		clientNonces        [][musig2.PubNonceSize]byte
-		serverNonces        [][musig2.PubNonceSize]byte
-		sessions            []*input.MuSig2SessionInfo
-		sweepTx             *wire.MsgTx
-		sweeplessClientSigs [][]byte
-	)
-	for feeRate, serverInfo := range fetchResp.FeeRateToNonces {
-		satPerKW := chainfee.SatPerKWeight(feeRate)
-		serverNonces, err = toNonces(serverInfo.Nonces)
-		if err != nil {
-			err = fmt.Errorf("unable to convert server nonces: %w",
-				err)
-			return f.HandleError(err)
-		}
-
-		sessions, nonces, err = f.loopIn.createMusig2Sessions(
-			ctx, f.cfg.Signer,
-		)
-		if err != nil {
-			return f.HandleError(err)
-		}
-
-		clientNonces, err = toNonces(nonces)
-		if err != nil {
-			return f.HandleError(err)
-		}
-
-		sweepTx, err = f.loopIn.createSweeplessSweepTx(
-			address, satPerKW,
-		)
-		if err != nil {
-			err = fmt.Errorf("unable to create sweepless sweep "+
-				"tx: %w", err)
-			return f.HandleError(err)
-		}
-
-		sweeplessClientSigs, err = f.loopIn.signMusig2Tx(
-			ctx, sweepTx, f.cfg.Signer, sessions, serverNonces,
-		)
-		if err != nil {
-			err = fmt.Errorf("unable to sign sweepless sweep tx: "+
-				"%w", err)
-			return f.HandleError(err)
-		}
-
-		clientResponse[feeRate] = &looprpc.ClientSweeplessSigningInfo{
-			Nonces: fromNonces(clientNonces),
-			Sigs:   sweeplessClientSigs,
-		}
-	}
-
-	// Push sweepless sigs to the server.
-	req := &looprpc.PushStaticAddressSweeplessSigsRequest{
-		SwapHash:    f.loopIn.SwapHash[:],
-		SigningInfo: clientResponse,
-	}
-	_, err = f.cfg.Server.PushStaticAddressSweeplessSigs(ctx, req)
-	if err != nil {
-		err = fmt.Errorf("unable to push sweepless sweep sigs: %w", err)
-
-		return f.HandleError(err)
-	}
-
-	return OnSweeplessSweepSigned
+	return OnSucceeded
 }
 
 // UnlockDepositsAction is called if the loop-in failed and its deposits should

staticaddr/loopin/fsm.go

@@ -111,18 +111,13 @@ var (
 	// transaction was sufficiently confirmed.
 	HtlcTimeoutSwept = fsm.StateType("HtlcTimeoutSwept")
 
-	// FetchSignPushSweeplessSweepTx is the state where the client fetches,
-	// signs and pushes the sweepless sweep tx signatures to the server.
-	FetchSignPushSweeplessSweepTx = fsm.StateType("FetchSignPushSweeplessSweepTx") //nolint:lll
-
 	// Succeeded is the state the swap is in if it was successful.
 	Succeeded = fsm.StateType("Succeeded")
 
-	// SucceededSweeplessSigFailed is the state the swap is in if the swap
-	// payment was received but the client failed to sign the sweepless
-	// sweep transaction. This is considered a successful case from the
-	// client's perspective.
-	SucceededSweeplessSigFailed = fsm.StateType("SucceededSweeplessSigFailed") //nolint:lll
+	// SucceededTransitioningFailed is the state the swap is in if the swap
+	// payment was received but the client was not able to transition
+	// the deposits to the looped-in state.
+	SucceededTransitioningFailed = fsm.StateType("SucceededTransitioningFailed") //nolint:lll
 
 	// UnlockDeposits is the state where the deposits are reset. This
 	// happens when the state machine encountered an error and the swap
@@ -135,30 +130,29 @@ var (
 
 var PendingStates = []fsm.StateType{
 	InitHtlcTx, SignHtlcTx, MonitorInvoiceAndHtlcTx, PaymentReceived,
-	SweepHtlcTimeout, MonitorHtlcTimeoutSweep, FetchSignPushSweeplessSweepTx,
+	SweepHtlcTimeout, MonitorHtlcTimeoutSweep,
 	UnlockDeposits,
 }
 
 var FinalStates = []fsm.StateType{
-	HtlcTimeoutSwept, Succeeded, SucceededSweeplessSigFailed, Failed,
+	HtlcTimeoutSwept, Succeeded, SucceededTransitioningFailed, Failed,
 }
 
 var AllStates = append(PendingStates, FinalStates...)
 
 // Events.
 var (
-	OnInitHtlc                      = fsm.EventType("OnInitHtlc")
-	OnHtlcInitiated                 = fsm.EventType("OnHtlcInitiated")
-	OnHtlcTxSigned                  = fsm.EventType("OnHtlcTxSigned")
-	OnSweepHtlcTimeout              = fsm.EventType("OnSweepHtlcTimeout")
-	OnHtlcTimeoutSweepPublished     = fsm.EventType("OnHtlcTimeoutSweepPublished")
-	OnHtlcTimeoutSwept              = fsm.EventType("OnHtlcTimeoutSwept")
-	OnPaymentReceived               = fsm.EventType("OnPaymentReceived")
-	OnPaymentDeadlineExceeded       = fsm.EventType("OnPaymentDeadlineExceeded")
-	OnSwapTimedOut                  = fsm.EventType("OnSwapTimedOut")
-	OnFetchSignPushSweeplessSweepTx = fsm.EventType("OnFetchSignPushSweeplessSweepTx")
-	OnSweeplessSweepSigned          = fsm.EventType("OnSweeplessSweepSigned")
-	OnRecover                       = fsm.EventType("OnRecover")
+	OnInitHtlc                  = fsm.EventType("OnInitHtlc")
+	OnHtlcInitiated             = fsm.EventType("OnHtlcInitiated")
+	OnHtlcTxSigned              = fsm.EventType("OnHtlcTxSigned")
+	OnSweepHtlcTimeout          = fsm.EventType("OnSweepHtlcTimeout")
+	OnHtlcTimeoutSweepPublished = fsm.EventType("OnHtlcTimeoutSweepPublished")
+	OnHtlcTimeoutSwept          = fsm.EventType("OnHtlcTimeoutSwept")
+	OnPaymentReceived           = fsm.EventType("OnPaymentReceived")
+	OnPaymentDeadlineExceeded   = fsm.EventType("OnPaymentDeadlineExceeded")
+	OnSwapTimedOut              = fsm.EventType("OnSwapTimedOut")
+	OnSucceeded                 = fsm.EventType("OnSucceeded")
+	OnRecover                   = fsm.EventType("OnRecover")
 )
 
 // LoopInStatesV0 returns the state and transition map for the loop-in state
@@ -215,27 +209,19 @@ func (f *FSM) LoopInStatesV0() fsm.States {
 		},
 		PaymentReceived: fsm.State{
 			Transitions: fsm.Transitions{
-				OnFetchSignPushSweeplessSweepTx: FetchSignPushSweeplessSweepTx,
-				OnRecover:                       SucceededSweeplessSigFailed,
-				fsm.OnError:                     SucceededSweeplessSigFailed,
+				OnSucceeded: Succeeded,
+				OnRecover:   Succeeded,
+				fsm.OnError: SucceededTransitioningFailed,
 			},
 			Action: f.PaymentReceivedAction,
 		},
-		FetchSignPushSweeplessSweepTx: fsm.State{
-			Transitions: fsm.Transitions{
-				OnSweeplessSweepSigned: Succeeded,
-				OnRecover:              SucceededSweeplessSigFailed,
-				fsm.OnError:            SucceededSweeplessSigFailed,
-			},
-			Action: f.FetchSignPushSweeplessSweepTxAction,
-		},
 		HtlcTimeoutSwept: fsm.State{
 			Action: fsm.NoOpAction,
 		},
 		Succeeded: fsm.State{
 			Action: fsm.NoOpAction,
 		},
-		SucceededSweeplessSigFailed: fsm.State{
+		SucceededTransitioningFailed: fsm.State{
 			Action: fsm.NoOpAction,
 		},
 		UnlockDeposits: fsm.State{