Merge pull request #184 from bhandras/native-segwit

support for native segwit loop-in

Author: joostjager

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,
 		})
 	}
 
@@ -464,15 +474,15 @@ func (s *Client) waitForInitialized(ctx context.Context) error {
 
 // LoopIn initiates a loop in swap.
 func (s *Client) LoopIn(globalCtx context.Context,
-	request *LoopInRequest) (*lntypes.Hash, btcutil.Address, error) {
+	request *LoopInRequest) (*LoopInSwapInfo, error) {
 
 	log.Infof("Loop in %v (last hop: %v)",
 		request.Amount,
 		request.LastHop,
 	)
 
 	if err := s.waitForInitialized(globalCtx); err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Create a new swap object for this swap.
@@ -486,15 +496,20 @@ func (s *Client) LoopIn(globalCtx context.Context,
 		globalCtx, &swapCfg, initiationHeight, request,
 	)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Post swap to the main loop.
 	s.executor.initiateSwap(globalCtx, swap)
 
 	// Return hash so that the caller can identify this swap in the updates
 	// stream.
-	return &swap.hash, swap.htlc.Address, nil
+	swapInfo := &LoopInSwapInfo{
+		SwapHash:          swap.hash,
+		HtlcAddressP2WSH:  swap.htlcP2WSH.Address,
+		HtlcAddressNP2WSH: swap.htlcNP2WSH.Address,
+	}
+	return swapInfo, nil
 }
 
 // LoopInQuote takes an amount and returns a break down of estimated

cmd/loop/loopin.go

@@ -153,7 +153,10 @@ func loopIn(ctx *cli.Context) error {
 
 	fmt.Printf("Swap initiated\n")
 	fmt.Printf("ID:           %v\n", resp.Id)
-	fmt.Printf("HTLC address: %v\n", resp.HtlcAddress)
+	if external {
+		fmt.Printf("HTLC address (NP2WSH): %v\n", resp.HtlcAddressNp2Wsh)
+	}
+	fmt.Printf("HTLC address (P2WSH): %v\n", resp.HtlcAddressP2Wsh)
 	fmt.Println()
 	fmt.Printf("Run `loop monitor` to monitor progress.\n")
 

cmd/loop/main.go

@@ -225,11 +225,24 @@ func parseAmt(text string) (btcutil.Amount, error) {
 }
 
 func logSwap(swap *looprpc.SwapStatus) {
-	fmt.Printf("%v %v %v %v - %v",
-		time.Unix(0, swap.LastUpdateTime).Format(time.RFC3339),
-		swap.Type, swap.State, btcutil.Amount(swap.Amt),
-		swap.HtlcAddress,
-	)
+	if swap.Type == looprpc.SwapType_LOOP_OUT {
+		fmt.Printf("%v %v %v %v - %v",
+			time.Unix(0, swap.LastUpdateTime).Format(time.RFC3339),
+			swap.Type, swap.State, btcutil.Amount(swap.Amt),
+			swap.HtlcAddressP2Wsh,
+		)
+	} else {
+		fmt.Printf("%v %v %v %v -",
+			time.Unix(0, swap.LastUpdateTime).Format(time.RFC3339),
+			swap.Type, swap.State, btcutil.Amount(swap.Amt))
+		if swap.HtlcAddressP2Wsh != "" {
+			fmt.Printf(" P2WSH: %v", swap.HtlcAddressP2Wsh)
+		}
+
+		if swap.HtlcAddressNp2Wsh != "" {
+			fmt.Printf(" NP2WSH: %v", swap.HtlcAddressNp2Wsh)
+		}
+	}
 
 	if swap.State != looprpc.SwapState_INITIATED &&
 		swap.State != looprpc.SwapState_HTLC_PUBLISHED &&

interface.go

@@ -235,6 +235,21 @@ type LoopInQuote struct {
 	CltvDelta int32
 }
 
+// LoopInSwapInfo contains essential information of a loop-in swap after the
+// swap is initiated.
+type LoopInSwapInfo struct { // nolint
+	// SwapHash contains the sha256 hash of the swap preimage.
+	SwapHash lntypes.Hash
+
+	// 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.
 type SwapInfoKit struct {
 	// Hash is the sha256 hash of the preimage that unlocks the htlcs. It
@@ -249,15 +264,27 @@ type SwapInfoKit struct {
 type SwapInfo struct {
 	loopdb.SwapStateData
 
+	loopdb.SwapContract
+
+	// LastUpdateTime is the time of the last state change.
 	LastUpdate time.Time
 
+	// SwapHash stores the swap preimage hash.
 	SwapHash lntypes.Hash
 
+	// SwapType describes whether this is a loop in or loop out swap.
 	SwapType swap.Type
 
-	loopdb.SwapContract
+	// HtlcAddressP2WSH stores the address of the P2WSH (native segwit)
+	// swap htlc. This is used for both loop-in and loop-out.
+	HtlcAddressP2WSH btcutil.Address
 
-	HtlcAddress 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
 }
 
 // LastUpdate returns the last update time of the swap

loopd/swapclient_server.go

@@ -126,27 +126,43 @@ 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
+		htlcAddressP2WSH = loopSwap.HtlcAddressP2WSH.EncodeAddress()
+
+		if loopSwap.ExternalHtlc {
+			htlcAddressNP2WSH = loopSwap.HtlcAddressNP2WSH.EncodeAddress()
+			htlcAddress = htlcAddressNP2WSH
+		} else {
+			htlcAddress = htlcAddressP2WSH
+		}
+
 	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
 }
 
@@ -255,6 +271,9 @@ func (s *swapClientServer) ListSwaps(_ context.Context,
 		err      error
 	)
 
+	s.swapsLock.Lock()
+	defer s.swapsLock.Unlock()
+
 	// We can just use the server's in-memory cache as that contains the
 	// most up-to-date state including temporary failures which aren't
 	// persisted to disk. The swaps field is a map, that's why we need an
@@ -409,17 +428,25 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
 		}
 		req.LastHop = &lastHop
 	}
-	hash, htlc, err := s.impl.LoopIn(ctx, req)
+	swapInfo, err := s.impl.LoopIn(ctx, req)
 	if err != nil {
 		log.Errorf("Loop in: %v", err)
 		return nil, err
 	}
 
-	return &looprpc.SwapResponse{
-		Id:          hash.String(),
-		IdBytes:     hash[:],
-		HtlcAddress: htlc.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.