loopin: enable p2tr htlcs without keyspend

Author: bhandras

client.go

@@ -213,35 +213,56 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 	}
 
 	for _, swp := range loopInSwaps {
-		htlcNP2WSH, err := swap.NewHtlc(
-			GetHtlcScriptVersion(swp.Contract.ProtocolVersion),
-			swp.Contract.CltvExpiry, swp.Contract.SenderKey,
-			swp.Contract.ReceiverKey, swp.Hash, swap.HtlcNP2WSH,
-			s.lndServices.ChainParams,
-		)
-		if err != nil {
-			return nil, err
+		swapInfo := &SwapInfo{
+			SwapType:      swap.TypeIn,
+			SwapContract:  swp.Contract.SwapContract,
+			SwapStateData: swp.State(),
+			SwapHash:      swp.Hash,
+			LastUpdate:    swp.LastUpdateTime(),
 		}
 
-		htlcP2WSH, err := swap.NewHtlc(
-			GetHtlcScriptVersion(swp.Contract.ProtocolVersion),
-			swp.Contract.CltvExpiry, swp.Contract.SenderKey,
-			swp.Contract.ReceiverKey, swp.Hash, swap.HtlcP2WSH,
-			s.lndServices.ChainParams,
+		scriptVersion := GetHtlcScriptVersion(
+			swp.Contract.SwapContract.ProtocolVersion,
 		)
-		if err != nil {
-			return nil, err
+
+		if scriptVersion == swap.HtlcV3 {
+			htlcP2TR, err := swap.NewHtlc(
+				swap.HtlcV3, swp.Contract.CltvExpiry,
+				swp.Contract.SenderKey, swp.Contract.ReceiverKey,
+				swp.Hash, swap.HtlcP2TR,
+				s.lndServices.ChainParams,
+			)
+			if err != nil {
+				return nil, err
+			}
+
+			swapInfo.HtlcAddressP2TR = htlcP2TR.Address
+		} else {
+			htlcNP2WSH, err := swap.NewHtlc(
+				swap.HtlcV1, swp.Contract.CltvExpiry,
+				swp.Contract.SenderKey, swp.Contract.ReceiverKey,
+				swp.Hash, swap.HtlcNP2WSH,
+				s.lndServices.ChainParams,
+			)
+			if err != nil {
+				return nil, err
+			}
+
+			htlcP2WSH, err := swap.NewHtlc(
+				swap.HtlcV2, swp.Contract.CltvExpiry,
+				swp.Contract.SenderKey, swp.Contract.ReceiverKey,
+				swp.Hash, swap.HtlcP2WSH,
+				s.lndServices.ChainParams,
+			)
+			if err != nil {
+				return nil, err
+			}
+
+			swapInfo.HtlcAddressP2WSH = htlcP2WSH.Address
+			swapInfo.HtlcAddressNP2WSH = htlcNP2WSH.Address
 		}
 
-		swaps = append(swaps, &SwapInfo{
-			SwapType:          swap.TypeIn,
-			SwapContract:      swp.Contract.SwapContract,
-			SwapStateData:     swp.State(),
-			SwapHash:          swp.Hash,
-			LastUpdate:        swp.LastUpdateTime(),
-			HtlcAddressP2WSH:  htlcP2WSH.Address,
-			HtlcAddressNP2WSH: htlcNP2WSH.Address,
-		})
+		swaps = append(swaps, swapInfo)
 	}
 
 	return swaps, nil
@@ -546,11 +567,17 @@ func (s *Client) LoopIn(globalCtx context.Context,
 	// Return hash so that the caller can identify this swap in the updates
 	// stream.
 	swapInfo := &LoopInSwapInfo{
-		SwapHash:          swap.hash,
-		HtlcAddressP2WSH:  swap.htlcP2WSH.Address,
-		HtlcAddressNP2WSH: swap.htlcNP2WSH.Address,
-		ServerMessage:     initResult.serverMessage,
+		SwapHash:      swap.hash,
+		ServerMessage: initResult.serverMessage,
 	}
+
+	if loopdb.CurrentProtocolVersion() < loopdb.ProtocolVersionHtlcV3 {
+		swapInfo.HtlcAddressNP2WSH = swap.htlcNP2WSH.Address
+		swapInfo.HtlcAddressP2WSH = swap.htlcP2WSH.Address
+	} else {
+		swapInfo.HtlcAddressP2TR = swap.htlcP2TR.Address
+	}
+
 	return swapInfo, nil
 }
 

cmd/loop/loopin.go

@@ -205,13 +205,20 @@ func loopIn(ctx *cli.Context) error {
 
 	fmt.Printf("Swap initiated\n")
 	fmt.Printf("ID:           %v\n", resp.Id)
-	if external {
-		fmt.Printf("HTLC address (NP2WSH): %v\n", resp.HtlcAddressNp2Wsh)
+	if resp.HtlcAddressP2Tr != "" {
+		fmt.Printf("HTLC address (P2TR): %v\n", resp.HtlcAddressP2Tr)
+	} else {
+		if external {
+			fmt.Printf("HTLC address (NP2WSH): %v\n",
+				resp.HtlcAddressNp2Wsh)
+		}
+		fmt.Printf("HTLC address (P2WSH): %v\n", resp.HtlcAddressP2Wsh)
 	}
-	fmt.Printf("HTLC address (P2WSH): %v\n", resp.HtlcAddressP2Wsh)
+
 	if resp.ServerMessage != "" {
 		fmt.Printf("Server message: %v\n", resp.ServerMessage)
 	}
+
 	fmt.Println()
 	fmt.Printf("Run `loop monitor` to monitor progress.\n")
 

cmd/loop/main.go

@@ -345,13 +345,18 @@ func logSwap(swap *looprpc.SwapStatus) {
 		fmt.Printf("%v %v %v %v -",
 			time.Unix(0, swap.LastUpdateTime).Format(time.RFC3339),
 			swap.Type, swapState, btcutil.Amount(swap.Amt))
+
 		if swap.HtlcAddressP2Wsh != "" {
 			fmt.Printf(" P2WSH: %v", swap.HtlcAddressP2Wsh)
 		}
 
 		if swap.HtlcAddressNp2Wsh != "" {
 			fmt.Printf(" NP2WSH: %v", swap.HtlcAddressNp2Wsh)
 		}
+
+		if swap.HtlcAddressP2Tr != "" {
+			fmt.Printf(" P2TR: %v", swap.HtlcAddressP2Tr)
+		}
 	}
 
 	if swap.State != looprpc.SwapState_INITIATED &&

interface.go

@@ -298,6 +298,9 @@ type LoopInSwapInfo struct { // nolint
 	// where the loop-in funds may be paid.
 	HtlcAddressNP2WSH btcutil.Address
 
+	// HtlcAddresP2TR contains the v3 (pay to taproot) htlc address.
+	HtlcAddressP2TR btcutil.Address
+
 	// ServerMessages is the human-readable message received from the loop
 	// server.
 	ServerMessage string
@@ -351,6 +354,10 @@ type SwapInfo struct {
 	// swap htlc. This is only used for external loop-in.
 	HtlcAddressNP2WSH btcutil.Address
 
+	// HtlcAddressP2TR stores the address of the P2TR (taproot) swap htlc.
+	// This is used for both internal and external loop-in and loop out.
+	HtlcAddressP2TR btcutil.Address
+
 	// ExternalHtlc is set to true for external loop-in swaps.
 	ExternalHtlc bool
 

liquidity/liquidity.go

@@ -407,8 +407,9 @@ func (m *Manager) autoloop(ctx context.Context) error {
 		}
 
 		log.Infof("loop in automatically dispatched: hash: %v, "+
-			"address: %v", loopIn.SwapHash,
-			loopIn.HtlcAddressNP2WSH)
+			"address: np2wsh(%v), p2wsh(%v), p2tr(%v)",
+			loopIn.SwapHash, loopIn.HtlcAddressNP2WSH,
+			loopIn.HtlcAddressP2WSH, loopIn.HtlcAddressP2TR)
 	}
 
 	return nil

loopd/swapclient_server.go

@@ -217,20 +217,33 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 	}
 
 	var swapType clientrpc.SwapType
-	var htlcAddress, htlcAddressP2WSH, htlcAddressNP2WSH string
+	var (
+		htlcAddress       string
+		htlcAddressP2TR   string
+		htlcAddressP2WSH  string
+		htlcAddressNP2WSH string
+	)
 	var outGoingChanSet []uint64
 	var lastHop []byte
 
 	switch loopSwap.SwapType {
 	case swap.TypeIn:
 		swapType = clientrpc.SwapType_LOOP_IN
-		htlcAddressP2WSH = loopSwap.HtlcAddressP2WSH.EncodeAddress()
 
-		if loopSwap.ExternalHtlc {
-			htlcAddressNP2WSH = loopSwap.HtlcAddressNP2WSH.EncodeAddress()
-			htlcAddress = htlcAddressNP2WSH
+		if loopSwap.HtlcAddressP2TR != nil {
+			htlcAddressP2TR = loopSwap.HtlcAddressP2TR.EncodeAddress()
+			htlcAddress = htlcAddressP2TR
 		} else {
-			htlcAddress = htlcAddressP2WSH
+			htlcAddressP2WSH =
+				loopSwap.HtlcAddressP2WSH.EncodeAddress()
+
+			if loopSwap.ExternalHtlc {
+				htlcAddressNP2WSH =
+					loopSwap.HtlcAddressNP2WSH.EncodeAddress()
+				htlcAddress = htlcAddressNP2WSH
+			} else {
+				htlcAddress = htlcAddressP2WSH
+			}
 		}
 
 		if loopSwap.LastHop != nil {
@@ -257,6 +270,7 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 		InitiationTime:    loopSwap.InitiationTime.UnixNano(),
 		LastUpdateTime:    loopSwap.LastUpdate.UnixNano(),
 		HtlcAddress:       htlcAddress,
+		HtlcAddressP2Tr:   htlcAddressP2TR,
 		HtlcAddressP2Wsh:  htlcAddressP2WSH,
 		HtlcAddressNp2Wsh: htlcAddressNP2WSH,
 		Type:              swapType,
@@ -618,8 +632,7 @@ func (s *swapClientServer) Probe(ctx context.Context,
 }
 
 func (s *swapClientServer) LoopIn(ctx context.Context,
-	in *clientrpc.LoopInRequest) (
-	*clientrpc.SwapResponse, error) {
+	in *clientrpc.LoopInRequest) (*clientrpc.SwapResponse, error) {
 
 	log.Infof("Loop in request received")
 
@@ -665,17 +678,25 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 	}
 
 	response := &clientrpc.SwapResponse{
-		Id:               swapInfo.SwapHash.String(),
-		IdBytes:          swapInfo.SwapHash[:],
-		HtlcAddressP2Wsh: swapInfo.HtlcAddressP2WSH.String(),
-		ServerMessage:    swapInfo.ServerMessage,
+		Id:            swapInfo.SwapHash.String(),
+		IdBytes:       swapInfo.SwapHash[:],
+		ServerMessage: swapInfo.ServerMessage,
 	}
 
-	if req.ExternalHtlc {
-		response.HtlcAddressNp2Wsh = swapInfo.HtlcAddressNP2WSH.String()
-		response.HtlcAddress = response.HtlcAddressNp2Wsh // nolint:staticcheck
+	if loopdb.CurrentProtocolVersion() < loopdb.ProtocolVersionHtlcV3 {
+		if req.ExternalHtlc {
+			np2wshAddr := swapInfo.HtlcAddressNP2WSH.String()
+			response.HtlcAddress = np2wshAddr
+			response.HtlcAddressNp2Wsh = np2wshAddr
+		} else {
+			p2wshAddr := swapInfo.HtlcAddressP2WSH.String()
+			response.HtlcAddress = p2wshAddr
+			response.HtlcAddressP2Wsh = p2wshAddr
+		}
 	} else {
-		response.HtlcAddress = response.HtlcAddressP2Wsh // nolint:staticcheck
+		p2trAddr := swapInfo.HtlcAddressP2TR.String()
+		response.HtlcAddress = p2trAddr
+		response.HtlcAddressP2Tr = p2trAddr
 	}
 
 	return response, nil

loopin.go

@@ -62,6 +62,8 @@ type loopInSwap struct {
 
 	htlcNP2WSH *swap.Htlc
 
+	htlcP2TR *swap.Htlc
+
 	// htlcTxHash is the confirmed htlc tx id.
 	htlcTxHash *chainhash.Hash
 
@@ -402,6 +404,18 @@ func validateLoopInContract(lnd *lndclient.LndServices,
 // initHtlcs creates and updates the native and nested segwit htlcs
 // of the loopInSwap.
 func (s *loopInSwap) initHtlcs() error {
+	if IsTaprootSwap(&s.SwapContract) {
+		htlcP2TR, err := s.swapKit.getHtlc(swap.HtlcP2TR)
+		if err != nil {
+			return err
+		}
+
+		s.swapKit.log.Infof("Htlc address (P2TR): %v", htlcP2TR.Address)
+		s.htlcP2TR = htlcP2TR
+
+		return nil
+	}
+
 	htlcP2WSH, err := s.swapKit.getHtlc(swap.HtlcP2WSH)
 	if err != nil {
 		return err
@@ -427,8 +441,13 @@ func (s *loopInSwap) sendUpdate(ctx context.Context) error {
 	info := s.swapInfo()
 	s.log.Infof("Loop in swap state: %v", info.State)
 
-	info.HtlcAddressP2WSH = s.htlcP2WSH.Address
-	info.HtlcAddressNP2WSH = s.htlcNP2WSH.Address
+	if IsTaprootSwap(&s.SwapContract) {
+		info.HtlcAddressP2TR = s.htlcP2TR.Address
+	} else {
+		info.HtlcAddressP2WSH = s.htlcP2WSH.Address
+		info.HtlcAddressNP2WSH = s.htlcNP2WSH.Address
+	}
+
 	info.ExternalHtlc = s.ExternalHtlc
 
 	// In order to avoid potentially dangerous ownership sharing
@@ -605,16 +624,29 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 
 	notifier := s.lnd.ChainNotifier
 
-	confChanP2WSH, confErrP2WSH, err := notifier.RegisterConfirmationsNtfn(
-		ctx, s.htlcTxHash, s.htlcP2WSH.PkScript, 1, s.InitiationHeight,
-	)
+	notifyConfirmation := func(htlc *swap.Htlc) (
+		chan *chainntnfs.TxConfirmation, chan error, error) {
+
+		if htlc == nil {
+			return nil, nil, nil
+		}
+
+		return notifier.RegisterConfirmationsNtfn(
+			ctx, s.htlcTxHash, htlc.PkScript, 1, s.InitiationHeight,
+		)
+	}
+
+	confChanP2WSH, confErrP2WSH, err := notifyConfirmation(s.htlcP2WSH)
 	if err != nil {
 		return nil, err
 	}
 
-	confChanNP2WSH, confErrNP2WSH, err := notifier.RegisterConfirmationsNtfn(
-		ctx, s.htlcTxHash, s.htlcNP2WSH.PkScript, 1, s.InitiationHeight,
-	)
+	confChanNP2WSH, confErrNP2WSH, err := notifyConfirmation(s.htlcNP2WSH)
+	if err != nil {
+		return nil, err
+	}
+
+	confChanP2TR, confErrP2TR, err := notifyConfirmation(s.htlcP2TR)
 	if err != nil {
 		return nil, err
 	}
@@ -633,6 +665,11 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 			s.htlc = s.htlcNP2WSH
 			s.log.Infof("NP2WSH htlc confirmed")
 
+		// P2TR htlc confirmed.
+		case conf = <-confChanP2TR:
+			s.htlc = s.htlcP2TR
+			s.log.Infof("P2TR htlc confirmed")
+
 		// Conf ntfn error.
 		case err := <-confErrP2WSH:
 			return nil, err
@@ -641,6 +678,10 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 		case err := <-confErrNP2WSH:
 			return nil, err
 
+		// Conf ntfn error.
+		case err := <-confErrP2TR:
+			return nil, err
+
 		// Keep up with block height.
 		case notification := <-s.blockEpochChan:
 			s.height = notification.(int32)
@@ -697,10 +738,16 @@ func (s *loopInSwap) publishOnChainHtlc(ctx context.Context) (bool, error) {
 
 	s.log.Infof("Publishing on chain HTLC with fee rate %v", feeRate)
 
-	// Internal loop-in is always P2WSH.
+	var pkScript []byte
+	if IsTaprootSwap(&s.SwapContract) {
+		pkScript = s.htlcP2TR.PkScript
+	} else {
+		pkScript = s.htlcP2WSH.PkScript
+	}
+
 	tx, err := s.lnd.WalletKit.SendOutputs(
 		ctx, []*wire.TxOut{{
-			PkScript: s.htlcP2WSH.PkScript,
+			PkScript: pkScript,
 			Value:    int64(s.LoopInContract.AmountRequested),
 		}}, feeRate, labels.LoopInHtlcLabel(swap.ShortHash(&s.hash)),
 	)