fixup! staticaddr/loopin: add listening for sweep request

Author: sputn1ck

staticaddr/loopin/interface.go

@@ -84,5 +84,5 @@ type NotificationManager interface {
 	// sweep requests. These are sent by the server to the client to request
 	// a sweep of a static loop in that has been finished.
 	SubscribeStaticLoopInSweepRequests(ctx context.Context,
-	) <-chan *swapserverrpc.ServerStaticLoopInSweepRequest
+	) <-chan *swapserverrpc.ServerStaticLoopInSweepNotification
 }

staticaddr/loopin/manager.go

@@ -24,6 +24,11 @@ import (
 	"github.com/lightningnetwork/lnd/routing/route"
 )
 
+var (
+	// errSwapNotFinished is returned when a swap is not finished.
+	errSwapNotFinished = fmt.Errorf("swap not finished")
+)
+
 // Config contains the services required for the loop-in manager.
 type Config struct {
 	// Server is the client that is used to communicate with the static
@@ -219,11 +224,23 @@ func (m *Manager) Run(ctx context.Context, currentHeight uint32) error {
 	}
 }
 
+// notifyNotFinished notifies the server that a swap is not finished by
+// sending an empty signature map.
+func (m *Manager) notifyNotFinished(ctx context.Context, swapHash lntypes.Hash,
+	txId chainhash.Hash) error {
+	_, err := m.cfg.Server.PushStaticAddressSweeplessSigs(
+		ctx, &looprpc.PushStaticAddressSweeplessSigsRequest{
+			SwapHash: swapHash[:],
+			Txid:     txId[:],
+		})
+	return err
+}
+
 // handleLoopInSweepReq handles a loop-in sweep request from the server.
 // It first checks if the requested loop-in is finished as expected and if
 // yes will send signature to the server for the provided psbt.
 func (m *Manager) handleLoopInSweepReq(ctx context.Context,
-	req *swapserverrpc.ServerStaticLoopInSweepRequest) error {
+	req *swapserverrpc.ServerStaticLoopInSweepNotification) error {
 
 	// First we'll check if the loop-ins are known to us and in
 	// the expected state.
@@ -238,11 +255,18 @@ func (m *Manager) handleLoopInSweepReq(ctx context.Context,
 		return err
 	}
 
-	// If the loop-in is not in the Succeeded state we return an
-	// error.
-	if loopIn.state != Succeeded {
-		return fmt.Errorf("loop-in %v not in Succeeded state",
-			swapHash)
+	loopIn.AddressParams, err =
+		m.cfg.AddressManager.GetStaticAddressParameters(ctx)
+
+	if err != nil {
+		return err
+	}
+
+	loopIn.Address, err = m.cfg.AddressManager.GetStaticAddress(
+		ctx,
+	)
+	if err != nil {
+		return err
 	}
 
 	reader := bytes.NewReader(req.SweepTxPsbt)
@@ -253,16 +277,58 @@ func (m *Manager) handleLoopInSweepReq(ctx context.Context,
 
 	sweepTx := sweepPacket.UnsignedTx
 
+	// If the loop-in is not in the Succeeded state we return an
+	// error.
+	if loopIn.state != Succeeded {
+		// We'll notify the server that we don't consider the swap
+		// finished yet, so it can retry later.
+		_ = m.notifyNotFinished(ctx, swapHash, sweepTx.TxHash())
+		return fmt.Errorf("loop-in %v not in Succeeded state",
+			swapHash)
+	}
+
 	// Perform a sanity check on the number of unsigned tx inputs and
 	// prevout info.
 	if len(sweepTx.TxIn) != len(req.PrevoutInfo) {
 		return fmt.Errorf("expected %v inputs, got %v",
 			len(req.PrevoutInfo), len(sweepTx.TxIn))
 	}
 
+	// Check if all the deposits requested are part of the loop-in and
+	// find them in the requested sweep.
+	depositToIdxMap := make(map[string]int)
+	for reqOutpoint := range req.DepositToNonces {
+		hasDeposit := false
+		for _, depositOutpoint := range loopIn.DepositOutpoints {
+			if depositOutpoint == reqOutpoint {
+				hasDeposit = true
+				break
+			}
+		}
+		if !hasDeposit {
+			return fmt.Errorf("deposit outpoint not part of " +
+				"loop-in")
+		}
+
+		foundDepositInTx := false
+
+		for i, txIn := range sweepTx.TxIn {
+			if txIn.PreviousOutPoint.String() == reqOutpoint {
+				depositToIdxMap[reqOutpoint] = i
+				foundDepositInTx = true
+				break
+			}
+		}
+
+		if !foundDepositInTx {
+			return fmt.Errorf("deposit outpoint not part of " +
+				"sweep tx")
+		}
+	}
+
 	prevoutMap := make(map[wire.OutPoint]*wire.TxOut)
-	var depositOutpoint *wire.OutPoint
 
+	// Set all the prevouts in the prevout map.
 	for i := range req.PrevoutInfo {
 		prevout := req.PrevoutInfo[i]
 
@@ -271,13 +337,6 @@ func (m *Manager) handleLoopInSweepReq(ctx context.Context,
 			return err
 		}
 
-		if i == int(req.OutputIndex) {
-			depositOutpoint = &wire.OutPoint{
-				Hash:  *txid,
-				Index: prevout.OutputIndex,
-			}
-		}
-
 		prevoutMap[wire.OutPoint{
 			Hash:  *txid,
 			Index: prevout.OutputIndex,
@@ -287,24 +346,6 @@ func (m *Manager) handleLoopInSweepReq(ctx context.Context,
 		}
 	}
 
-	// Check if the deposit outpoint is part of the loop-in.
-	if depositOutpoint == nil {
-		return fmt.Errorf("deposit outpoint not part of loop-in")
-	}
-
-	foundDeposit := false
-	for _, loopInDeposit := range loopIn.DepositOutpoints {
-		if loopInDeposit == fmt.Sprintf("%v:%v",
-			depositOutpoint.Hash, depositOutpoint.Index) {
-
-			foundDeposit = true
-		}
-	}
-
-	if !foundDeposit {
-		return fmt.Errorf("deposit outpoint not part of loop-in")
-	}
-
 	prevOutputFetcher := txscript.NewMultiPrevOutFetcher(
 		prevoutMap,
 	)
@@ -313,65 +354,67 @@ func (m *Manager) handleLoopInSweepReq(ctx context.Context,
 		sweepPacket.UnsignedTx, prevOutputFetcher,
 	)
 
-	taprootSigHash, err := txscript.CalcTaprootSignatureHash(
-		sigHashes, txscript.SigHashDefault, sweepPacket.UnsignedTx,
-		int(req.OutputIndex), prevOutputFetcher,
-	)
-	if err != nil {
-		return err
-	}
+	// We'll now sign for every deposit that is part of the loop-in.
+	responseMap := make(map[string]*looprpc.ClientSweeplessSigningInfo)
+	for depositOutpoint, nonce := range req.DepositToNonces {
+		taprootSigHash, err := txscript.CalcTaprootSignatureHash(
+			sigHashes, txscript.SigHashDefault, sweepPacket.UnsignedTx,
+			depositToIdxMap[depositOutpoint], prevOutputFetcher,
+		)
+		if err != nil {
+			return err
+		}
 
-	var (
-		serverNonce [musig2.PubNonceSize]byte
-		sigHash     [32]byte
-	)
+		var (
+			serverNonce [musig2.PubNonceSize]byte
+			sigHash     [32]byte
+		)
 
-	copy(serverNonce[:], req.Nonce)
-	musig2Session, err := loopIn.createMusig2Session(ctx, m.cfg.Signer)
-	if err != nil {
-		return err
-	}
+		copy(serverNonce[:], nonce)
+		musig2Session, err := loopIn.createMusig2Session(
+			ctx, m.cfg.Signer,
+		)
+		if err != nil {
+			return err
+		}
 
-	haveAllNonces, err := m.cfg.Signer.MuSig2RegisterNonces(
-		ctx, musig2Session.SessionID,
-		[][musig2.PubNonceSize]byte{serverNonce},
-	)
-	if err != nil {
-		return err
-	}
+		haveAllNonces, err := m.cfg.Signer.MuSig2RegisterNonces(
+			ctx, musig2Session.SessionID,
+			[][musig2.PubNonceSize]byte{serverNonce},
+		)
+		if err != nil {
+			return err
+		}
 
-	if !haveAllNonces {
-		return fmt.Errorf("expected all nonces to be registered")
-	}
+		if !haveAllNonces {
+			return fmt.Errorf("expected all nonces to be " +
+				"registered")
+		}
 
-	copy(sigHash[:], taprootSigHash)
+		copy(sigHash[:], taprootSigHash)
 
-	// Since our MuSig2 session has all nonces, we can now create
-	// the local partial signature by signing the sig hash.
-	sig, err := m.cfg.Signer.MuSig2Sign(
-		ctx, musig2Session.SessionID, sigHash, false,
-	)
-	if err != nil {
-		return err
+		// Since our MuSig2 session has all nonces, we can now create
+		// the local partial signature by signing the sig hash.
+		sig, err := m.cfg.Signer.MuSig2Sign(
+			ctx, musig2Session.SessionID, sigHash, true,
+		)
+		if err != nil {
+			return err
+		}
+
+		responseMap[depositOutpoint] = &looprpc.ClientSweeplessSigningInfo{ //nolint:lll
+			Nonce: musig2Session.PublicNonce[:],
+			Sig:   sig,
+		}
 	}
 
 	txHash := sweepTx.TxHash()
 
-	// We'll now push the signature to the server.
-	msg := &looprpc.PushSingleDepositVersion{
-		TxHash:      txHash[:],
-		OutputIndex: req.OutputIndex,
-		Nonce:       musig2Session.PublicNonce[:],
-		Sig:         sig,
-	}
-
 	_, err = m.cfg.Server.PushStaticAddressSweeplessSigs(
 		ctx, &looprpc.PushStaticAddressSweeplessSigsRequest{
-
-			SwapHash: loopIn.SwapHash[:],
-			Message: &looprpc.PushStaticAddressSweeplessSigsRequest_SingleDepositVersion{ //nolint:lll
-				SingleDepositVersion: msg,
-			},
+			SwapHash:    loopIn.SwapHash[:],
+			Txid:        txHash[:],
+			SigningInfo: responseMap,
 		},
 	)
 	return err