Merge pull request #248 from joostjager/user-expiry

loopout: user-specified expiry

Author: joostjager

client.go

@@ -3,6 +3,7 @@ package loop
 import (
 	"context"
 	"errors"
+	"fmt"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -33,20 +34,10 @@ var (
 	// more than the server maximum.
 	ErrSwapAmountTooHigh = errors.New("swap amount too high")
 
-	// ErrExpiryTooSoon is returned when the server proposes an expiry that
-	// is too soon for us.
-	ErrExpiryTooSoon = errors.New("swap expiry too soon")
-
 	// ErrExpiryTooFar is returned when the server proposes an expiry that
 	// is too soon for us.
 	ErrExpiryTooFar = errors.New("swap expiry too far")
 
-	// ErrSweepConfTargetTooFar is returned when the client proposes a
-	// confirmation target to sweep the on-chain HTLC of a Loop Out that is
-	// beyond the expiration height proposed by the server.
-	ErrSweepConfTargetTooFar = errors.New("sweep confirmation target is " +
-		"beyond swap expiration height")
-
 	// serverRPCTimeout is the maximum time a gRPC request to the server
 	// should be allowed to take.
 	serverRPCTimeout = 30 * time.Second
@@ -363,8 +354,21 @@ func (s *Client) LoopOut(globalCtx context.Context,
 		return nil, err
 	}
 
-	// Create a new swap object for this swap.
+	// Calculate htlc expiry height.
+	terms, err := s.Server.GetLoopOutTerms(globalCtx)
+	if err != nil {
+		return nil, err
+	}
+
 	initiationHeight := s.executor.height()
+	request.Expiry, err = s.getExpiry(
+		initiationHeight, terms, request.SweepConfTarget,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a new swap object for this swap.
 	swapCfg := newSwapConfig(s.lndServices, s.Store, s.Server)
 	initResult, err := newLoopOutSwap(
 		globalCtx, swapCfg, initiationHeight, request,
@@ -386,6 +390,24 @@ func (s *Client) LoopOut(globalCtx context.Context,
 	}, nil
 }
 
+// getExpiry returns an absolute expiry height based on the sweep confirmation
+// target, constrained by the server terms.
+func (s *Client) getExpiry(height int32, terms *LoopOutTerms,
+	confTarget int32) (int32, error) {
+
+	switch {
+	case confTarget < terms.MinCltvDelta:
+		return height + terms.MinCltvDelta, nil
+
+	case confTarget > terms.MaxCltvDelta:
+		return 0, fmt.Errorf("confirmation target %v exceeds maximum "+
+			"server cltv delta of %v", confTarget,
+			terms.MaxCltvDelta)
+	}
+
+	return height + confTarget, nil
+}
+
 // LoopOutQuote takes a LoopOut amount and returns a break down of estimated
 // costs for the client. Both the swap server and the on-chain fee estimator
 // are queried to get to build the quote response.
@@ -405,8 +427,14 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 		return nil, ErrSwapAmountTooHigh
 	}
 
+	height := s.executor.height()
+	expiry, err := s.getExpiry(height, terms, request.SweepConfTarget)
+	if err != nil {
+		return nil, err
+	}
+
 	quote, err := s.Server.GetLoopOutQuote(
-		ctx, request.Amount, request.SwapPublicationDeadline,
+		ctx, request.Amount, expiry, request.SwapPublicationDeadline,
 	)
 	if err != nil {
 		return nil, err
@@ -440,7 +468,6 @@ func (s *Client) LoopOutQuote(ctx context.Context,
 		MinerFee:        minerFee,
 		PrepayAmount:    quote.PrepayAmount,
 		SwapPaymentDest: quote.SwapPaymentDest,
-		CltvDelta:       quote.CltvDelta,
 	}, nil
 }
 

cmd/loop/terms.go

@@ -39,6 +39,9 @@ func terms(ctx *cli.Context) error {
 			loopOutTerms.MinSwapAmount,
 			loopOutTerms.MaxSwapAmount,
 		)
+		fmt.Printf("Cltv delta: %d - %d\n",
+			loopOutTerms.MinCltvDelta, loopOutTerms.MaxCltvDelta,
+		)
 	}
 
 	fmt.Println()

interface.go

@@ -71,6 +71,9 @@ type OutRequest struct {
 	// SwapPublicationDeadline can be set by the client to allow the server
 	// delaying publication of the swap HTLC to save on chain fees.
 	SwapPublicationDeadline time.Time
+
+	// Expiry is the absolute expiry height of the on-chain htlc.
+	Expiry int32
 }
 
 // Out contains the full details of a loop out request. This includes things
@@ -124,6 +127,12 @@ type LoopOutTerms struct {
 	// MaxSwapAmount is the maximum amount that the server accepts for a
 	// swap.
 	MaxSwapAmount btcutil.Amount
+
+	// MinCltvDelta is the minimum expiry delta for loop out swaps.
+	MinCltvDelta int32
+
+	// MaxCltvDelta is the maximum expiry delta for loop out swaps.
+	MaxCltvDelta int32
 }
 
 // LoopOutQuote contains estimates for the fees making up the total swap cost
@@ -140,10 +149,6 @@ type LoopOutQuote struct {
 	// sweep the htlc.
 	MinerFee btcutil.Amount
 
-	// Time lock delta relative to current block height that swap server
-	// will accept on the swap initiation call.
-	CltvDelta int32
-
 	// SwapPaymentDest is the node pubkey where to swap payment needs to be
 	// sent to.
 	SwapPaymentDest [33]byte

loopd/swapclient_server.go

@@ -341,6 +341,8 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context,
 	return &looprpc.OutTermsResponse{
 		MinSwapAmount: int64(terms.MinSwapAmount),
 		MaxSwapAmount: int64(terms.MaxSwapAmount),
+		MinCltvDelta:  terms.MinCltvDelta,
+		MaxCltvDelta:  terms.MaxCltvDelta,
 	}, nil
 }
 
@@ -371,7 +373,6 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
 		PrepayAmtSat:    int64(quote.PrepayAmount),
 		SwapFeeSat:      int64(quote.SwapFee),
 		SwapPaymentDest: quote.SwapPaymentDest[:],
-		CltvDelta:       quote.CltvDelta,
 	}, nil
 }
 

loopout.go

@@ -106,13 +106,14 @@ func newLoopOutSwap(globalCtx context.Context, cfg *swapConfig,
 
 	// Post the swap parameters to the swap server. The response contains
 	// the server revocation key and the swap and prepay invoices.
-	log.Infof("Initiating swap request at height %v", currentHeight)
+	log.Infof("Initiating swap request at height %v: amt=%v, expiry=%v",
+		currentHeight, request.Amount, request.Expiry)
 
 	// The swap deadline will be given to the server for it to use as the
 	// latest swap publication time.
 	swapResp, err := cfg.server.NewLoopOutSwap(
-		globalCtx, swapHash, request.Amount, receiverKey,
-		request.SwapPublicationDeadline,
+		globalCtx, swapHash, request.Amount, request.Expiry,
+		receiverKey, request.SwapPublicationDeadline,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("cannot initiate swap: %v", err)
@@ -150,7 +151,7 @@ func newLoopOutSwap(globalCtx context.Context, cfg *swapConfig,
 			SenderKey:        swapResp.senderKey,
 			Preimage:         swapPreimage,
 			AmountRequested:  request.Amount,
-			CltvExpiry:       swapResp.expiry,
+			CltvExpiry:       request.Expiry,
 			MaxMinerFee:      request.MaxMinerFee,
 			MaxSwapFee:       request.MaxSwapFee,
 		},
@@ -994,18 +995,5 @@ func validateLoopOutContract(lnd *lndclient.LndServices,
 		return ErrPrepayAmountTooHigh
 	}
 
-	if response.expiry-height < MinLoopOutPreimageRevealDelta {
-		log.Warnf("Proposed expiry %v (delta %v) too soon",
-			response.expiry, response.expiry-height)
-
-		return ErrExpiryTooSoon
-	}
-
-	// Ensure the client has provided a sweep confirmation target that does
-	// not exceed the height at which we revert back to using the default.
-	if height+request.SweepConfTarget >= response.expiry-DefaultSweepConfTargetDelta {
-		return ErrSweepConfTargetTooFar
-	}
-
 	return nil
 }

loopout_test.go

@@ -151,6 +151,8 @@ func TestLateHtlcPublish(t *testing.T) {
 
 	cfg := newSwapConfig(&lnd.LndServices, store, server)
 
+	testRequest.Expiry = height + testLoopOutMinOnChainCltvDelta
+
 	initResult, err := newLoopOutSwap(
 		context.Background(), cfg, height, testRequest,
 	)
@@ -225,20 +227,22 @@ func TestCustomSweepConfTarget(t *testing.T) {
 
 	// Use the highest sweep confirmation target before we attempt to use
 	// the default.
-	testRequest.SweepConfTarget = testLoopOutOnChainCltvDelta -
+	testReq := *testRequest
+
+	testReq.SweepConfTarget = testLoopOutMinOnChainCltvDelta -
 		DefaultSweepConfTargetDelta - 1
 
 	// Set up custom fee estimates such that the lower confirmation target
 	// yields a much higher fee rate.
-	ctx.Lnd.SetFeeEstimate(testRequest.SweepConfTarget, 250)
+	ctx.Lnd.SetFeeEstimate(testReq.SweepConfTarget, 250)
 	ctx.Lnd.SetFeeEstimate(DefaultSweepConfTarget, 10000)
 
 	cfg := newSwapConfig(
 		&lnd.LndServices, newStoreMock(t), server,
 	)
 
 	initResult, err := newLoopOutSwap(
-		context.Background(), cfg, ctx.Lnd.Height, testRequest,
+		context.Background(), cfg, ctx.Lnd.Height, &testReq,
 	)
 	if err != nil {
 		t.Fatal(err)
@@ -357,7 +361,7 @@ func TestCustomSweepConfTarget(t *testing.T) {
 
 	// The sweep should have a fee that corresponds to the custom
 	// confirmation target.
-	_ = assertSweepTx(testRequest.SweepConfTarget)
+	_ = assertSweepTx(testReq.SweepConfTarget)
 
 	// Once we have published an on chain sweep, we expect a preimage to
 	// have been pushed to our server.
@@ -374,8 +378,8 @@ func TestCustomSweepConfTarget(t *testing.T) {
 
 	// We'll then notify the height at which we begin using the default
 	// confirmation target.
-	defaultConfTargetHeight := ctx.Lnd.Height + testLoopOutOnChainCltvDelta -
-		DefaultSweepConfTargetDelta
+	defaultConfTargetHeight := ctx.Lnd.Height +
+		testLoopOutMinOnChainCltvDelta - DefaultSweepConfTargetDelta
 	blockEpochChan <- int32(defaultConfTargetHeight)
 	expiryChan <- time.Now()
 
@@ -424,15 +428,17 @@ func TestPreimagePush(t *testing.T) {
 
 	// Start with a high confirmation delta which will have a very high fee
 	// attached to it.
-	testRequest.SweepConfTarget = testLoopOutOnChainCltvDelta -
+	testReq := *testRequest
+	testReq.SweepConfTarget = testLoopOutMinOnChainCltvDelta -
 		DefaultSweepConfTargetDelta - 1
+	testReq.Expiry = ctx.Lnd.Height + testLoopOutMinOnChainCltvDelta
 
 	// We set our mock fee estimate for our target sweep confs to be our
 	// max miner fee *2, so that our fee will definitely be above what we
 	// are willing to pay, and we will not sweep.
 	ctx.Lnd.SetFeeEstimate(
-		testRequest.SweepConfTarget, chainfee.SatPerKWeight(
-			testRequest.MaxMinerFee*2,
+		testReq.SweepConfTarget, chainfee.SatPerKWeight(
+			testReq.MaxMinerFee*2,
 		),
 	)
 
@@ -446,7 +452,7 @@ func TestPreimagePush(t *testing.T) {
 	)
 
 	initResult, err := newLoopOutSwap(
-		context.Background(), cfg, ctx.Lnd.Height, testRequest,
+		context.Background(), cfg, ctx.Lnd.Height, &testReq,
 	)
 	require.NoError(t, err)
 	swap := initResult.swap
@@ -517,7 +523,7 @@ func TestPreimagePush(t *testing.T) {
 	// Now, we notify the height at which the client will start using the
 	// default confirmation target. This has the effect of lowering our fees
 	// so that the client still start sweeping.
-	defaultConfTargetHeight := ctx.Lnd.Height + testLoopOutOnChainCltvDelta -
+	defaultConfTargetHeight := ctx.Lnd.Height + testLoopOutMinOnChainCltvDelta -
 		DefaultSweepConfTargetDelta
 	blockEpochChan <- defaultConfTargetHeight