looprpc+loopin: support for native segwit htlcs

This commit extends SwapResponse and SwapStatus with np2wsh and p2wsh
htlc output addresses to support both nested and native segwit htlcs
in loop-in.

Furthermore the commit adds support for native segwith loop-in htlcs.
When the htlc is paid internally, as of this commit we'll use NP2WSH,
otherwise users are free to select whether to pay the NP2WSH or the
P2WSH htlc.

Author: bhandras

client.go

@@ -194,17 +194,17 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 		}
 
 		swaps = append(swaps, &SwapInfo{
-			SwapType:      swap.TypeOut,
-			SwapContract:  swp.Contract.SwapContract,
-			SwapStateData: swp.State(),
-			SwapHash:      swp.Hash,
-			LastUpdate:    swp.LastUpdateTime(),
-			HtlcAddress:   htlc.Address,
+			SwapType:         swap.TypeOut,
+			SwapContract:     swp.Contract.SwapContract,
+			SwapStateData:    swp.State(),
+			SwapHash:         swp.Hash,
+			LastUpdate:       swp.LastUpdateTime(),
+			HtlcAddressP2WSH: htlc.Address,
 		})
 	}
 
 	for _, swp := range loopInSwaps {
-		htlc, err := swap.NewHtlc(
+		htlcNP2WSH, err := swap.NewHtlc(
 			swp.Contract.CltvExpiry, swp.Contract.SenderKey,
 			swp.Contract.ReceiverKey, swp.Hash, swap.HtlcNP2WSH,
 			s.lndServices.ChainParams,
@@ -213,13 +213,23 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 			return nil, err
 		}
 
+		htlcP2WSH, err := swap.NewHtlc(
+			swp.Contract.CltvExpiry, swp.Contract.SenderKey,
+			swp.Contract.ReceiverKey, swp.Hash, swap.HtlcP2WSH,
+			s.lndServices.ChainParams,
+		)
+		if err != nil {
+			return nil, err
+		}
+
 		swaps = append(swaps, &SwapInfo{
-			SwapType:      swap.TypeIn,
-			SwapContract:  swp.Contract.SwapContract,
-			SwapStateData: swp.State(),
-			SwapHash:      swp.Hash,
-			LastUpdate:    swp.LastUpdateTime(),
-			HtlcAddress:   htlc.Address,
+			SwapType:          swap.TypeIn,
+			SwapContract:      swp.Contract.SwapContract,
+			SwapStateData:     swp.State(),
+			SwapHash:          swp.Hash,
+			LastUpdate:        swp.LastUpdateTime(),
+			HtlcAddressP2WSH:  htlcP2WSH.Address,
+			HtlcAddressNP2WSH: htlcNP2WSH.Address,
 		})
 	}
 
@@ -495,8 +505,9 @@ 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,
-		HtlcAddress: swap.htlc.Address,
+		SwapHash:          swap.hash,
+		HtlcAddressP2WSH:  swap.htlcP2WSH.Address,
+		HtlcAddressNP2WSH: swap.htlcNP2WSH.Address,
 	}
 	return swapInfo, nil
 }

interface.go

@@ -241,9 +241,13 @@ type LoopInSwapInfo struct { // nolint
 	// SwapHash contains the sha256 hash of the swap preimage.
 	SwapHash lntypes.Hash
 
-	// HtlcAddress contains the swap htlc address, where the loop-in
-	// funds will be paid.
-	HtlcAddress btcutil.Address
+	// HtlcAddressP2WSH contains the native segwit swap htlc address,
+	// where the loop-in funds may be paid.
+	HtlcAddressP2WSH btcutil.Address
+
+	// HtlcAddressNP2WSH contains the nested segwit swap htlc address,
+	// where the loop-in funds may be paid.
+	HtlcAddressNP2WSH btcutil.Address
 }
 
 // SwapInfoKit contains common swap info fields.
@@ -271,8 +275,13 @@ type SwapInfo struct {
 	// SwapType describes whether this is a loop in or loop out swap.
 	SwapType swap.Type
 
-	// HtlcAddress holds the HTLC address of the swap.
-	HtlcAddress btcutil.Address
+	// HtlcAddressP2WSH stores the address of the P2WSH (native segwit)
+	// swap htlc. This is used for both loop-in and loop-out.
+	HtlcAddressP2WSH btcutil.Address
+
+	// HtlcAddressNP2WSH stores the address of the NP2WSH (nested segwit)
+	// swap htlc. This is only used for external loop-in.
+	HtlcAddressNP2WSH btcutil.Address
 
 	// ExternalHtlc is set to true for external loop-in swaps.
 	ExternalHtlc bool

loopd/swapclient_server.go

@@ -126,27 +126,40 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 	}
 
 	var swapType looprpc.SwapType
+	var htlcAddress, htlcAddressP2WSH, htlcAddressNP2WSH string
+
 	switch loopSwap.SwapType {
 	case swap.TypeIn:
 		swapType = looprpc.SwapType_LOOP_IN
+		if loopSwap.ExternalHtlc {
+			htlcAddressP2WSH = loopSwap.HtlcAddressP2WSH.EncodeAddress()
+		}
+		htlcAddressNP2WSH = loopSwap.HtlcAddressNP2WSH.EncodeAddress()
+		htlcAddress = htlcAddressNP2WSH
+
 	case swap.TypeOut:
 		swapType = looprpc.SwapType_LOOP_OUT
+		htlcAddressP2WSH = loopSwap.HtlcAddressP2WSH.EncodeAddress()
+		htlcAddress = htlcAddressP2WSH
+
 	default:
 		return nil, errors.New("unknown swap type")
 	}
 
 	return &looprpc.SwapStatus{
-		Amt:            int64(loopSwap.AmountRequested),
-		Id:             loopSwap.SwapHash.String(),
-		IdBytes:        loopSwap.SwapHash[:],
-		State:          state,
-		InitiationTime: loopSwap.InitiationTime.UnixNano(),
-		LastUpdateTime: loopSwap.LastUpdate.UnixNano(),
-		HtlcAddress:    loopSwap.HtlcAddress.EncodeAddress(),
-		Type:           swapType,
-		CostServer:     int64(loopSwap.Cost.Server),
-		CostOnchain:    int64(loopSwap.Cost.Onchain),
-		CostOffchain:   int64(loopSwap.Cost.Offchain),
+		Amt:               int64(loopSwap.AmountRequested),
+		Id:                loopSwap.SwapHash.String(),
+		IdBytes:           loopSwap.SwapHash[:],
+		State:             state,
+		InitiationTime:    loopSwap.InitiationTime.UnixNano(),
+		LastUpdateTime:    loopSwap.LastUpdate.UnixNano(),
+		HtlcAddress:       htlcAddress,
+		HtlcAddressP2Wsh:  htlcAddressP2WSH,
+		HtlcAddressNp2Wsh: htlcAddressNP2WSH,
+		Type:              swapType,
+		CostServer:        int64(loopSwap.Cost.Server),
+		CostOnchain:       int64(loopSwap.Cost.Onchain),
+		CostOffchain:      int64(loopSwap.Cost.Offchain),
 	}, nil
 }
 
@@ -418,11 +431,19 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 		return nil, err
 	}
 
-	return &looprpc.SwapResponse{
-		Id:          swapInfo.SwapHash.String(),
-		IdBytes:     swapInfo.SwapHash[:],
-		HtlcAddress: swapInfo.HtlcAddress.String(),
-	}, nil
+	np2wshAddress := swapInfo.HtlcAddressNP2WSH.String()
+	response := &looprpc.SwapResponse{
+		Id:                swapInfo.SwapHash.String(),
+		IdBytes:           swapInfo.SwapHash[:],
+		HtlcAddress:       np2wshAddress,
+		HtlcAddressNp2Wsh: np2wshAddress,
+	}
+
+	if req.ExternalHtlc {
+		response.HtlcAddressP2Wsh = swapInfo.HtlcAddressP2WSH.String()
+	}
+
+	return response, nil
 }
 
 // GetLsatTokens returns all tokens that are contained in the LSAT token store.

loopin.go

@@ -54,6 +54,10 @@ type loopInSwap struct {
 
 	htlc *swap.Htlc
 
+	htlcP2WSH *swap.Htlc
+
+	htlcNP2WSH *swap.Htlc
+
 	timeoutAddr btcutil.Address
 }
 
@@ -158,19 +162,13 @@ func newLoopInSwap(globalCtx context.Context, cfg *swapConfig,
 
 	swapKit.lastUpdateTime = initiationTime
 
-	// Create the htlc.
-	htlc, err := swapKit.getHtlc(swap.HtlcNP2WSH)
-	if err != nil {
-		return nil, err
-	}
-
-	// Log htlc address for debugging.
-	swapKit.log.Infof("Htlc address: %v", htlc.Address)
-
 	swap := &loopInSwap{
 		LoopInContract: contract,
 		swapKit:        *swapKit,
-		htlc:           htlc,
+	}
+
+	if err := swap.initHtlcs(); err != nil {
+		return nil, err
 	}
 
 	// Persist the data before exiting this function, so that the caller can
@@ -196,19 +194,13 @@ func resumeLoopInSwap(reqContext context.Context, cfg *swapConfig,
 		hash, swap.TypeIn, cfg, &pend.Contract.SwapContract,
 	)
 
-	// Create the htlc.
-	htlc, err := swapKit.getHtlc(swap.HtlcNP2WSH)
-	if err != nil {
-		return nil, err
-	}
-
-	// Log htlc address for debugging.
-	swapKit.log.Infof("Htlc address: %v", htlc.Address)
-
 	swap := &loopInSwap{
 		LoopInContract: *pend.Contract,
 		swapKit:        *swapKit,
-		htlc:           htlc,
+	}
+
+	if err := swap.initHtlcs(); err != nil {
+		return nil, err
 	}
 
 	lastUpdate := pend.LastUpdate()
@@ -238,12 +230,36 @@ func validateLoopInContract(lnd *lndclient.LndServices,
 	return nil
 }
 
+// initHtlcs creates and updates the native and nested segwit htlcs
+// of the loopInSwap.
+func (s *loopInSwap) initHtlcs() error {
+	htlcP2WSH, err := s.swapKit.getHtlc(swap.HtlcP2WSH)
+	if err != nil {
+		return err
+	}
+
+	htlcNP2WSH, err := s.swapKit.getHtlc(swap.HtlcNP2WSH)
+	if err != nil {
+		return err
+	}
+
+	// Log htlc addresses for debugging.
+	s.swapKit.log.Infof("Htlc address (P2WSH): %v", htlcP2WSH.Address)
+	s.swapKit.log.Infof("Htlc address (NP2WSH): %v", htlcNP2WSH.Address)
+
+	s.htlcP2WSH = htlcP2WSH
+	s.htlcNP2WSH = htlcNP2WSH
+
+	return nil
+}
+
 // sendUpdate reports an update to the swap state.
 func (s *loopInSwap) sendUpdate(ctx context.Context) error {
 	info := s.swapInfo()
 	s.log.Infof("Loop in swap state: %v", info.State)
 
-	info.HtlcAddress = s.htlc.Address
+	info.HtlcAddressP2WSH = s.htlcP2WSH.Address
+	info.HtlcAddressNP2WSH = s.htlcNP2WSH.Address
 	info.ExternalHtlc = s.ExternalHtlc
 
 	select {
@@ -373,21 +389,44 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 
 	ctx, cancel := context.WithCancel(globalCtx)
 	defer cancel()
-	confChan, confErr, err := s.lnd.ChainNotifier.RegisterConfirmationsNtfn(
-		ctx, nil, s.htlc.PkScript, 1, s.InitiationHeight,
+
+	notifier := s.lnd.ChainNotifier
+
+	confChanP2WSH, confErrP2WSH, err := notifier.RegisterConfirmationsNtfn(
+		ctx, nil, s.htlcP2WSH.PkScript, 1, s.InitiationHeight,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	confChanNP2WSH, confErrNP2WSH, err := notifier.RegisterConfirmationsNtfn(
+		ctx, nil, s.htlcNP2WSH.PkScript, 1, s.InitiationHeight,
 	)
 	if err != nil {
 		return nil, err
 	}
+
 	for {
 		select {
 
-		// Htlc confirmed.
-		case conf := <-confChan:
+		// P2WSH htlc confirmed.
+		case conf := <-confChanP2WSH:
+			s.htlc = s.htlcP2WSH
+			s.log.Infof("P2WSH htlc confirmed")
+			return conf, nil
+
+		// NP2WSH htlc confirmed.
+		case conf := <-confChanNP2WSH:
+			s.htlc = s.htlcNP2WSH
+			s.log.Infof("NP2WSH htlc confirmed")
 			return conf, nil
 
 		// Conf ntfn error.
-		case err := <-confErr:
+		case err := <-confErrP2WSH:
+			return nil, err
+
+		// Conf ntfn error.
+		case err := <-confErrNP2WSH:
 			return nil, err
 
 		// Keep up with block height.
@@ -432,9 +471,10 @@ func (s *loopInSwap) publishOnChainHtlc(ctx context.Context) (bool, error) {
 	}
 
 	s.log.Infof("Publishing on chain HTLC with fee rate %v", feeRate)
+
 	tx, err := s.lnd.WalletKit.SendOutputs(ctx,
 		[]*wire.TxOut{{
-			PkScript: s.htlc.PkScript,
+			PkScript: s.htlcNP2WSH.PkScript,
 			Value:    int64(s.LoopInContract.AmountRequested),
 		}},
 		feeRate,