multi: completely remove support for NP2WSH htlcs

This commit removes all code related to NP2WSH htlcs. These were
historically used when segwit adoption was very sporadic and are not
used anywhere anymore. Some historical swaps stored in the DB may be
listed with incorrect htlc adresses from here on.

Author: bhandras

client.go

@@ -267,16 +267,6 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 
 			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,
@@ -288,7 +278,6 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 			}
 
 			swapInfo.HtlcAddressP2WSH = htlcP2WSH.Address
-			swapInfo.HtlcAddressNP2WSH = htlcNP2WSH.Address
 		}
 
 		swaps = append(swaps, swapInfo)
@@ -615,7 +604,6 @@ func (s *Client) LoopIn(globalCtx context.Context,
 	}
 
 	if loopdb.CurrentProtocolVersion() < loopdb.ProtocolVersionHtlcV3 {
-		swapInfo.HtlcAddressNP2WSH = swap.htlcNP2WSH.Address
 		swapInfo.HtlcAddressP2WSH = swap.htlcP2WSH.Address
 	} else {
 		swapInfo.HtlcAddressP2TR = swap.htlcP2TR.Address

client_test.go

@@ -370,9 +370,6 @@ func testLoopOutSuccess(ctx *testContext, amt btcutil.Amount, hash lntypes.Hash,
 
 	var preImageIndex int
 	switch scriptVersion {
-	case swap.HtlcV1:
-		preImageIndex = 1
-
 	case swap.HtlcV2:
 		preImageIndex = 0
 

cmd/loop/loopin.go

@@ -208,10 +208,6 @@ func loopIn(ctx *cli.Context) error {
 	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)
 	}
 

cmd/loop/main.go

@@ -350,10 +350,6 @@ func logSwap(swap *looprpc.SwapStatus) {
 			fmt.Printf(" P2WSH: %v", swap.HtlcAddressP2Wsh)
 		}
 
-		if swap.HtlcAddressNp2Wsh != "" {
-			fmt.Printf(" NP2WSH: %v", swap.HtlcAddressNp2Wsh)
-		}
-
 		if swap.HtlcAddressP2Tr != "" {
 			fmt.Printf(" P2TR: %v", swap.HtlcAddressP2Tr)
 		}

interface.go

@@ -294,10 +294,6 @@ type LoopInSwapInfo struct { // nolint
 	// 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
-
 	// HtlcAddresP2TR contains the v3 (pay to taproot) htlc address.
 	HtlcAddressP2TR btcutil.Address
 
@@ -350,10 +346,6 @@ type SwapInfo struct {
 	// 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
-
 	// 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

liquidity/liquidity.go

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

loopd/swapclient_server.go

@@ -230,10 +230,9 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 
 	var swapType clientrpc.SwapType
 	var (
-		htlcAddress       string
-		htlcAddressP2TR   string
-		htlcAddressP2WSH  string
-		htlcAddressNP2WSH string
+		htlcAddress      string
+		htlcAddressP2TR  string
+		htlcAddressP2WSH string
 	)
 	var outGoingChanSet []uint64
 	var lastHop []byte
@@ -248,14 +247,7 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 		} else {
 			htlcAddressP2WSH =
 				loopSwap.HtlcAddressP2WSH.EncodeAddress()
-
-			if loopSwap.ExternalHtlc {
-				htlcAddressNP2WSH =
-					loopSwap.HtlcAddressNP2WSH.EncodeAddress()
-				htlcAddress = htlcAddressNP2WSH
-			} else {
-				htlcAddress = htlcAddressP2WSH
-			}
+			htlcAddress = htlcAddressP2WSH
 		}
 
 		if loopSwap.LastHop != nil {
@@ -279,24 +271,23 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
 	}
 
 	return &clientrpc.SwapStatus{
-		Amt:               int64(loopSwap.AmountRequested),
-		Id:                loopSwap.SwapHash.String(),
-		IdBytes:           loopSwap.SwapHash[:],
-		State:             state,
-		FailureReason:     failureReason,
-		InitiationTime:    loopSwap.InitiationTime.UnixNano(),
-		LastUpdateTime:    loopSwap.LastUpdate.UnixNano(),
-		HtlcAddress:       htlcAddress,
-		HtlcAddressP2Tr:   htlcAddressP2TR,
-		HtlcAddressP2Wsh:  htlcAddressP2WSH,
-		HtlcAddressNp2Wsh: htlcAddressNP2WSH,
-		Type:              swapType,
-		CostServer:        int64(loopSwap.Cost.Server),
-		CostOnchain:       int64(loopSwap.Cost.Onchain),
-		CostOffchain:      int64(loopSwap.Cost.Offchain),
-		Label:             loopSwap.Label,
-		LastHop:           lastHop,
-		OutgoingChanSet:   outGoingChanSet,
+		Amt:              int64(loopSwap.AmountRequested),
+		Id:               loopSwap.SwapHash.String(),
+		IdBytes:          loopSwap.SwapHash[:],
+		State:            state,
+		FailureReason:    failureReason,
+		InitiationTime:   loopSwap.InitiationTime.UnixNano(),
+		LastUpdateTime:   loopSwap.LastUpdate.UnixNano(),
+		HtlcAddress:      htlcAddress,
+		HtlcAddressP2Tr:  htlcAddressP2TR,
+		HtlcAddressP2Wsh: htlcAddressP2WSH,
+		Type:             swapType,
+		CostServer:       int64(loopSwap.Cost.Server),
+		CostOnchain:      int64(loopSwap.Cost.Onchain),
+		CostOffchain:     int64(loopSwap.Cost.Offchain),
+		Label:            loopSwap.Label,
+		LastHop:          lastHop,
+		OutgoingChanSet:  outGoingChanSet,
 	}, nil
 }
 
@@ -701,15 +692,9 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 	}
 
 	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
-		}
+		p2wshAddr := swapInfo.HtlcAddressP2WSH.String()
+		response.HtlcAddress = p2wshAddr
+		response.HtlcAddressP2Wsh = p2wshAddr
 	} else {
 		p2trAddr := swapInfo.HtlcAddressP2TR.String()
 		response.HtlcAddress = p2trAddr

loopd/view.go

@@ -55,9 +55,6 @@ func viewOut(swapClient *loop.Client, chainParams *chaincfg.Params) error {
 
 		var outputType swap.HtlcOutputType
 		switch scriptVersion {
-		case swap.HtlcV1:
-			outputType = swap.HtlcNP2WSH
-
 		case swap.HtlcV2:
 			outputType = swap.HtlcP2WSH
 

loopin.go

@@ -61,8 +61,6 @@ type loopInSwap struct {
 
 	htlcP2WSH *swap.Htlc
 
-	htlcNP2WSH *swap.Htlc
-
 	htlcP2TR *swap.Htlc
 
 	// htlcTxHash is the confirmed htlc tx id.
@@ -423,17 +421,9 @@ func (s *loopInSwap) initHtlcs() error {
 		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
 }
@@ -447,7 +437,6 @@ func (s *loopInSwap) sendUpdate(ctx context.Context) error {
 		info.HtlcAddressP2TR = s.htlcP2TR.Address
 	} else {
 		info.HtlcAddressP2WSH = s.htlcP2WSH.Address
-		info.HtlcAddressNP2WSH = s.htlcNP2WSH.Address
 	}
 
 	info.ExternalHtlc = s.ExternalHtlc
@@ -643,11 +632,6 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 		return nil, err
 	}
 
-	confChanNP2WSH, confErrNP2WSH, err := notifyConfirmation(s.htlcNP2WSH)
-	if err != nil {
-		return nil, err
-	}
-
 	confChanP2TR, confErrP2TR, err := notifyConfirmation(s.htlcP2TR)
 	if err != nil {
 		return nil, err
@@ -662,11 +646,6 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 			s.htlc = s.htlcP2WSH
 			s.log.Infof("P2WSH htlc confirmed")
 
-		// NP2WSH htlc confirmed.
-		case conf = <-confChanNP2WSH:
-			s.htlc = s.htlcNP2WSH
-			s.log.Infof("NP2WSH htlc confirmed")
-
 		// P2TR htlc confirmed.
 		case conf = <-confChanP2TR:
 			s.htlc = s.htlcP2TR
@@ -676,10 +655,6 @@ func (s *loopInSwap) waitForHtlcConf(globalCtx context.Context) (
 		case err := <-confErrP2WSH:
 			return nil, err
 
-		// Conf ntfn error.
-		case err := <-confErrNP2WSH:
-			return nil, err
-
 		// Conf ntfn error.
 		case err := <-confErrP2TR:
 			return nil, err

loopin_test.go

@@ -104,12 +104,6 @@ func testLoopInSuccess(t *testing.T) {
 	// Expect register for htlc conf (only one, since the htlc is p2tr).
 	<-ctx.lnd.RegisterConfChannel
 
-	// If the swap is legacy, then we'll register two confirmation
-	// notifications.
-	if !IsTaprootSwap(&inSwap.SwapContract) {
-		<-ctx.lnd.RegisterConfChannel
-	}
-
 	// Confirm htlc.
 	ctx.lnd.ConfChannel <- &chainntnfs.TxConfirmation{
 		Tx: &htlcTx,
@@ -266,11 +260,7 @@ func testLoopInTimeout(t *testing.T, externalValue int64) {
 		// Create an external htlc publish tx.
 		var pkScript []byte
 		if !IsTaprootSwap(&inSwap.SwapContract) {
-			if req.ExternalHtlc {
-				pkScript = inSwap.htlcNP2WSH.PkScript
-			} else {
-				pkScript = inSwap.htlcP2WSH.PkScript
-			}
+			pkScript = inSwap.htlcP2WSH.PkScript
 		} else {
 			pkScript = inSwap.htlcP2TR.PkScript
 		}
@@ -288,12 +278,6 @@ func testLoopInTimeout(t *testing.T, externalValue int64) {
 	// Expect register for htlc conf.
 	<-ctx.lnd.RegisterConfChannel
 
-	// If the swap is legacy, then we'll register two confirmation
-	// notifications.
-	if !IsTaprootSwap(&inSwap.SwapContract) {
-		<-ctx.lnd.RegisterConfChannel
-	}
-
 	// Confirm htlc.
 	ctx.lnd.ConfChannel <- &chainntnfs.TxConfirmation{
 		Tx: &htlcTx,
@@ -473,7 +457,7 @@ func testLoopInResume(t *testing.T, state loopdb.SwapState, expired bool,
 
 	scriptVersion := GetHtlcScriptVersion(storedVersion)
 
-	outputType := swap.HtlcNP2WSH
+	outputType := swap.HtlcP2WSH
 	if scriptVersion == swap.HtlcV3 {
 		outputType = swap.HtlcP2TR
 	}
@@ -571,12 +555,6 @@ func testLoopInResume(t *testing.T, state loopdb.SwapState, expired bool,
 	// Expect register for htlc conf.
 	<-ctx.lnd.RegisterConfChannel
 
-	// If the swap is legacy, then we'll register two confirmation
-	// notifications.
-	if !IsTaprootSwap(&inSwap.SwapContract) {
-		<-ctx.lnd.RegisterConfChannel
-	}
-
 	// Confirm htlc.
 	ctx.lnd.ConfChannel <- &chainntnfs.TxConfirmation{
 		Tx: &htlcTx,