Merge pull request #541 from bhandras/htlc-v3-interal-key

swap: refactor htlc construction to allow passing of internal keys

Author: bhandras

client.go

@@ -213,29 +213,24 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 			SwapHash:      swp.Hash,
 			LastUpdate:    swp.LastUpdateTime(),
 		}
-		scriptVersion := GetHtlcScriptVersion(
-			swp.Contract.ProtocolVersion,
-		)
-
-		outputType := swap.HtlcP2WSH
-		if scriptVersion == swap.HtlcV3 {
-			outputType = swap.HtlcP2TR
-		}
 
-		htlc, err := swap.NewHtlc(
-			scriptVersion,
-			swp.Contract.CltvExpiry, swp.Contract.SenderKey,
-			swp.Contract.ReceiverKey, swp.Hash,
-			outputType, s.lndServices.ChainParams,
+		htlc, err := GetHtlc(
+			swp.Hash, &swp.Contract.SwapContract,
+			s.lndServices.ChainParams,
 		)
 		if err != nil {
 			return nil, err
 		}
 
-		if outputType == swap.HtlcP2TR {
-			swapInfo.HtlcAddressP2TR = htlc.Address
-		} else {
+		switch htlc.OutputType {
+		case swap.HtlcP2WSH:
 			swapInfo.HtlcAddressP2WSH = htlc.Address
+
+		case swap.HtlcP2TR:
+			swapInfo.HtlcAddressP2TR = htlc.Address
+
+		default:
+			return nil, swap.ErrInvalidOutputType
 		}
 
 		swaps = append(swaps, swapInfo)
@@ -250,34 +245,23 @@ func (s *Client) FetchSwaps() ([]*SwapInfo, error) {
 			LastUpdate:    swp.LastUpdateTime(),
 		}
 
-		scriptVersion := GetHtlcScriptVersion(
-			swp.Contract.SwapContract.ProtocolVersion,
+		htlc, err := GetHtlc(
+			swp.Hash, &swp.Contract.SwapContract,
+			s.lndServices.ChainParams,
 		)
+		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
-			}
+		switch htlc.OutputType {
+		case swap.HtlcP2WSH:
+			swapInfo.HtlcAddressP2WSH = htlc.Address
 
-			swapInfo.HtlcAddressP2TR = htlcP2TR.Address
-		} else {
-			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
-			}
+		case swap.HtlcP2TR:
+			swapInfo.HtlcAddressP2TR = htlc.Address
 
-			swapInfo.HtlcAddressP2WSH = htlcP2WSH.Address
+		default:
+			return nil, swap.ErrInvalidOutputType
 		}
 
 		swaps = append(swaps, swapInfo)

client_test.go

@@ -1,7 +1,6 @@
 package loop
 
 import (
-	"bytes"
 	"context"
 	"crypto/sha256"
 	"errors"
@@ -57,9 +56,7 @@ func TestLoopOutSuccess(t *testing.T) {
 
 	// Initiate loop out.
 	info, err := ctx.swapClient.LoopOut(context.Background(), &req)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	ctx.assertStored()
 	ctx.assertStatus(loopdb.StateInitiated)
@@ -84,9 +81,7 @@ func TestLoopOutFailOffchain(t *testing.T) {
 	ctx := createClientTestContext(t, nil)
 
 	_, err := ctx.swapClient.LoopOut(context.Background(), testRequest)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	ctx.assertStored()
 	ctx.assertStatus(loopdb.StateInitiated)
@@ -208,14 +203,10 @@ func testLoopOutResume(t *testing.T, confs uint32, expired, preimageRevealed,
 	amt := btcutil.Amount(50000)
 
 	swapPayReq, err := getInvoice(hash, amt, swapInvoiceDesc)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	prePayReq, err := getInvoice(hash, 100, prepayInvoiceDesc)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	_, senderPubKey := test.CreateKey(1)
 	var senderKey [33]byte
@@ -284,16 +275,26 @@ func testLoopOutResume(t *testing.T, confs uint32, expired, preimageRevealed,
 
 	// Assert that the loopout htlc equals to the expected one.
 	scriptVersion := GetHtlcScriptVersion(protocolVersion)
+	var htlc *swap.Htlc
 
-	outputType := swap.HtlcP2TR
-	if scriptVersion != swap.HtlcV3 {
-		outputType = swap.HtlcP2WSH
+	switch scriptVersion {
+	case swap.HtlcV2:
+		htlc, err = swap.NewHtlcV2(
+			pendingSwap.Contract.CltvExpiry, senderKey,
+			receiverKey, hash, &chaincfg.TestNet3Params,
+		)
+
+	case swap.HtlcV3:
+		htlc, err = swap.NewHtlcV3(
+			pendingSwap.Contract.CltvExpiry, senderKey,
+			receiverKey, senderKey, receiverKey, hash,
+			&chaincfg.TestNet3Params,
+		)
+
+	default:
+		t.Fatalf(swap.ErrInvalidScriptVersion.Error())
 	}
 
-	htlc, err := swap.NewHtlc(
-		scriptVersion, pendingSwap.Contract.CltvExpiry, senderKey,
-		receiverKey, hash, outputType, &chaincfg.TestNet3Params,
-	)
 	require.NoError(t, err)
 	require.Equal(t, htlc.PkScript, confIntent.PkScript)
 
@@ -363,10 +364,11 @@ func testLoopOutSuccess(ctx *testContext, amt btcutil.Amount, hash lntypes.Hash,
 	// Expect client on-chain sweep of HTLC.
 	sweepTx := ctx.ReceiveTx()
 
-	if !bytes.Equal(sweepTx.TxIn[0].PreviousOutPoint.Hash[:],
-		htlcOutpoint.Hash[:]) {
-		ctx.T.Fatalf("client not sweeping from htlc tx")
-	}
+	require.Equal(
+		ctx.T, htlcOutpoint.Hash[:],
+		sweepTx.TxIn[0].PreviousOutPoint.Hash[:],
+		"client not sweeping from htlc tx",
+	)
 
 	var preImageIndex int
 	switch scriptVersion {
@@ -380,9 +382,7 @@ func testLoopOutSuccess(ctx *testContext, amt btcutil.Amount, hash lntypes.Hash,
 	// Check preimage.
 	clientPreImage := sweepTx.TxIn[0].Witness[preImageIndex]
 	clientPreImageHash := sha256.Sum256(clientPreImage)
-	if clientPreImageHash != hash {
-		ctx.T.Fatalf("incorrect preimage")
-	}
+	require.Equal(ctx.T, hash, lntypes.Hash(clientPreImageHash))
 
 	// Since we successfully published our sweep, we expect the preimage to
 	// have been pushed to our mock server.

loopd/swapclient_server_test.go

@@ -130,16 +130,13 @@ func TestValidateConfTarget(t *testing.T) {
 				test.confTarget, defaultConf,
 			)
 
-			haveErr := err != nil
-			if haveErr != test.expectErr {
-				t.Fatalf("expected err: %v, got: %v",
-					test.expectErr, err)
+			if test.expectErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
 			}
 
-			if target != test.expectedTarget {
-				t.Fatalf("expected: %v, got: %v",
-					test.expectedTarget, target)
-			}
+			require.Equal(t, test.expectedTarget, target)
 		})
 	}
 }
@@ -199,16 +196,13 @@ func TestValidateLoopInRequest(t *testing.T) {
 				test.confTarget, external,
 			)
 
-			haveErr := err != nil
-			if haveErr != test.expectErr {
-				t.Fatalf("expected err: %v, got: %v",
-					test.expectErr, err)
+			if test.expectErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
 			}
 
-			if conf != test.expectedTarget {
-				t.Fatalf("expected: %v, got: %v",
-					test.expectedTarget, conf)
-			}
+			require.Equal(t, test.expectedTarget, conf)
 		})
 	}
 }

loopd/view.go

@@ -7,7 +7,6 @@ import (
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/loopdb"
-	"github.com/lightninglabs/loop/swap"
 )
 
 // view prints all swaps currently in the database.
@@ -49,24 +48,8 @@ func viewOut(swapClient *loop.Client, chainParams *chaincfg.Params) error {
 	}
 
 	for _, s := range swaps {
-		scriptVersion := loop.GetHtlcScriptVersion(
-			s.Contract.ProtocolVersion,
-		)
-
-		var outputType swap.HtlcOutputType
-		switch scriptVersion {
-		case swap.HtlcV2:
-			outputType = swap.HtlcP2WSH
-
-		case swap.HtlcV3:
-			outputType = swap.HtlcP2TR
-		}
-		htlc, err := swap.NewHtlc(
-			loop.GetHtlcScriptVersion(s.Contract.ProtocolVersion),
-			s.Contract.CltvExpiry,
-			s.Contract.SenderKey,
-			s.Contract.ReceiverKey,
-			s.Hash, outputType, chainParams,
+		htlc, err := loop.GetHtlc(
+			s.Hash, &s.Contract.SwapContract, chainParams,
 		)
 		if err != nil {
 			return err
@@ -77,7 +60,8 @@ func viewOut(swapClient *loop.Client, chainParams *chaincfg.Params) error {
 			s.Contract.InitiationTime, s.Contract.InitiationHeight,
 		)
 		fmt.Printf("   Preimage: %v\n", s.Contract.Preimage)
-		fmt.Printf("   Htlc address: %v\n", htlc.Address)
+		fmt.Printf("   Htlc address (%s): %v\n", htlc.OutputType,
+			htlc.Address)
 
 		fmt.Printf("   Uncharge channels: %v\n",
 			s.Contract.OutgoingChanSet)
@@ -113,12 +97,8 @@ func viewIn(swapClient *loop.Client, chainParams *chaincfg.Params) error {
 	}
 
 	for _, s := range swaps {
-		htlc, err := swap.NewHtlc(
-			loop.GetHtlcScriptVersion(s.Contract.ProtocolVersion),
-			s.Contract.CltvExpiry,
-			s.Contract.SenderKey,
-			s.Contract.ReceiverKey,
-			s.Hash, swap.HtlcP2WSH, chainParams,
+		htlc, err := loop.GetHtlc(
+			s.Hash, &s.Contract.SwapContract, chainParams,
 		)
 		if err != nil {
 			return err
@@ -129,7 +109,8 @@ func viewIn(swapClient *loop.Client, chainParams *chaincfg.Params) error {
 			s.Contract.InitiationTime, s.Contract.InitiationHeight,
 		)
 		fmt.Printf("   Preimage: %v\n", s.Contract.Preimage)
-		fmt.Printf("   Htlc address: %v\n", htlc.Address)
+		fmt.Printf("   Htlc address (%s): %v\n", htlc.OutputType,
+			htlc.Address)
 		fmt.Printf("   Amt: %v, Expiry: %v\n",
 			s.Contract.AmountRequested, s.Contract.CltvExpiry,
 		)

loopin.go

@@ -404,26 +404,26 @@ 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
-		}
+	htlc, err := GetHtlc(
+		s.hash, &s.SwapContract, s.swapKit.lnd.ChainParams,
+	)
+	if err != nil {
+		return err
+	}
 
-		s.swapKit.log.Infof("Htlc address (P2TR): %v", htlcP2TR.Address)
-		s.htlcP2TR = htlcP2TR
+	switch htlc.OutputType {
+	case swap.HtlcP2WSH:
+		s.htlcP2WSH = htlc
 
-		return nil
-	}
+	case swap.HtlcP2TR:
+		s.htlcP2TR = htlc
 
-	htlcP2WSH, err := s.swapKit.getHtlc(swap.HtlcP2WSH)
-	if err != nil {
-		return err
+	default:
+		return fmt.Errorf("invalid output type")
 	}
 
-	// Log htlc addresses for debugging.
-	s.swapKit.log.Infof("Htlc address (P2WSH): %v", htlcP2WSH.Address)
-	s.htlcP2WSH = htlcP2WSH
+	s.swapKit.log.Infof("Htlc address (%s): %v", htlc.OutputType,
+		htlc.Address)
 
 	return nil
 }