Merge pull request #542 from GeorgeTsagk/autoloop-custom-addr

liquidity: add `destaddr` parameter for autoloop loop out

Author: sputn1ck

cmd/loop/liquidity.go

@@ -286,6 +286,12 @@ var setParamsCommand = cli.Command{
 				"of swaps, limited to the budget set by " +
 				"autobudget",
 		},
+		cli.StringFlag{
+			Name: "destaddr",
+			Usage: "custom address to be used as destination for " +
+				"autoloop loop out, set to \"default\" in " +
+				"order to revert to default behavior",
+		},
 		cli.Uint64Flag{
 			Name: "autobudget",
 			Usage: "the maximum amount of fees in satoshis that " +
@@ -429,6 +435,11 @@ func setParams(ctx *cli.Context) error {
 		flagSet = true
 	}
 
+	if ctx.IsSet("destaddr") {
+		params.AutoloopDestAddress = ctx.String("destaddr")
+		flagSet = true
+	}
+
 	if ctx.IsSet("budgetstart") {
 		params.AutoloopBudgetStartSec = ctx.Uint64("budgetstart")
 		flagSet = true

liquidity/autoloop_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/stretchr/testify/require"
 )
 
 // TestAutoLoopDisabled tests the case where we need to perform a swap, but
@@ -307,6 +308,156 @@ func TestAutoLoopEnabled(t *testing.T) {
 	c.stop()
 }
 
+// TestAutoloopAddress tests that the custom destination address feature for
+// loop out behaves as expected.
+func TestAutoloopAddress(t *testing.T) {
+	defer test.Guard(t)()
+
+	// Decode a dummy p2wkh address to use as the destination address for
+	// the swaps.
+	p2wkhAddr := "bcrt1qq68r6ff4k4pjx39efs44gcyccf7unqnu5qtjjz"
+	addr, err := btcutil.DecodeAddress(p2wkhAddr, nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	var (
+		channels = []lndclient.ChannelInfo{
+			channel1, channel2,
+		}
+
+		swapFeePPM   uint64 = 1000
+		routeFeePPM  uint64 = 1000
+		prepayFeePPM uint64 = 1000
+		prepayAmount        = btcutil.Amount(20000)
+		maxMiner            = btcutil.Amount(20000)
+
+		// Create some dummy parameters for autoloop and also specify an
+		// destination address.
+		params = Parameters{
+			Autoloop:         true,
+			AutoFeeBudget:    40066,
+			DestAddr:         addr,
+			AutoFeeStartDate: testTime,
+			MaxAutoInFlight:  2,
+			FailureBackOff:   time.Hour,
+			SweepConfTarget:  10,
+			FeeLimit: NewFeeCategoryLimit(
+				swapFeePPM, routeFeePPM, prepayFeePPM, maxMiner,
+				prepayAmount, 20000,
+			),
+			ChannelRules: map[lnwire.ShortChannelID]*SwapRule{
+				chanID1: chanRule,
+				chanID2: chanRule,
+			},
+			HtlcConfTarget: defaultHtlcConfTarget,
+		}
+	)
+	c := newAutoloopTestCtx(t, params, channels, testRestrictions)
+	c.start()
+
+	// Get parameters from manager and verify that address is set correctly.
+	params = c.manager.GetParameters()
+	require.Equal(t, params.DestAddr, addr)
+
+	// Calculate our maximum allowed fees and create quotes that fall within
+	// our budget.
+	var (
+		amt = chan1Rec.Amount
+
+		maxSwapFee = ppmToSat(amt, swapFeePPM)
+
+		quote1 = &loop.LoopOutQuote{
+			SwapFee:      maxSwapFee,
+			PrepayAmount: prepayAmount - 10,
+			MinerFee:     maxMiner - 10,
+		}
+
+		quote2 = &loop.LoopOutQuote{
+			SwapFee:      maxSwapFee,
+			PrepayAmount: prepayAmount - 20,
+			MinerFee:     maxMiner - 10,
+		}
+
+		quoteRequest = &loop.LoopOutQuoteRequest{
+			Amount:          amt,
+			SweepConfTarget: params.SweepConfTarget,
+		}
+
+		quotes = []quoteRequestResp{
+			{
+				request: quoteRequest,
+				quote:   quote1,
+			},
+			{
+				request: quoteRequest,
+				quote:   quote2,
+			},
+		}
+
+		maxRouteFee = ppmToSat(amt, routeFeePPM)
+
+		chan1Swap = &loop.OutRequest{
+			Amount: amt,
+			// Define the expected destination address.
+			DestAddr:          addr,
+			MaxSwapRoutingFee: maxRouteFee,
+			MaxPrepayRoutingFee: ppmToSat(
+				quote1.PrepayAmount, prepayFeePPM,
+			),
+			MaxSwapFee:      quote1.SwapFee,
+			MaxPrepayAmount: quote1.PrepayAmount,
+			MaxMinerFee:     maxMiner,
+			SweepConfTarget: params.SweepConfTarget,
+			OutgoingChanSet: loopdb.ChannelSet{chanID1.ToUint64()},
+			Label:           labels.AutoloopLabel(swap.TypeOut),
+			Initiator:       autoloopSwapInitiator,
+		}
+
+		chan2Swap = &loop.OutRequest{
+			Amount: amt,
+			// Define the expected destination address.
+			DestAddr:          addr,
+			MaxSwapRoutingFee: maxRouteFee,
+			MaxPrepayRoutingFee: ppmToSat(
+				quote2.PrepayAmount, routeFeePPM,
+			),
+			MaxSwapFee:      quote2.SwapFee,
+			MaxPrepayAmount: quote2.PrepayAmount,
+			MaxMinerFee:     maxMiner,
+			SweepConfTarget: params.SweepConfTarget,
+			OutgoingChanSet: loopdb.ChannelSet{chanID2.ToUint64()},
+			Label:           labels.AutoloopLabel(swap.TypeOut),
+			Initiator:       autoloopSwapInitiator,
+		}
+
+		loopOuts = []loopOutRequestResp{
+			{
+				request: chan1Swap,
+				response: &loop.LoopOutSwapInfo{
+					SwapHash: lntypes.Hash{1},
+				},
+			},
+			{
+				request: chan2Swap,
+				response: &loop.LoopOutSwapInfo{
+					SwapHash: lntypes.Hash{2},
+				},
+			},
+		}
+	)
+
+	step := &autoloopStep{
+		minAmt:      1,
+		maxAmt:      amt + 1,
+		quotesOut:   quotes,
+		expectedOut: loopOuts,
+	}
+	c.autoloop(step)
+
+	c.stop()
+}
+
 // TestCompositeRules tests the case where we have rules set on a per peer
 // and per channel basis, and perform swaps for both targets.
 func TestCompositeRules(t *testing.T) {

liquidity/autoloop_testcontext_test.go

@@ -304,7 +304,9 @@ func (c *autoloopTestCtx) autoloop(step *autoloopStep) {
 
 		// Set our destination address to nil so that we do not need to
 		// provide the address that is obtained by the mock wallet kit.
-		actual.DestAddr = nil
+		if expected.request.DestAddr == nil {
+			actual.DestAddr = nil
+		}
 
 		assert.Equal(c.t, expected.request, actual)
 		c.loopOut <- expected.response

liquidity/liquidity.go

@@ -380,6 +380,13 @@ func (m *Manager) autoloop(ctx context.Context) error {
 
 		// Create a copy of our range var so that we can reference it.
 		swap := swap
+
+		// Check if the parameter for custom address is defined for loop
+		// outs.
+		if m.params.DestAddr != nil {
+			swap.DestAddr = m.params.DestAddr
+		}
+
 		loopOut, err := m.cfg.LoopOut(ctx, &swap)
 		if err != nil {
 			return err

liquidity/parameters.go

@@ -18,9 +18,10 @@ import (
 
 var (
 	// defaultParameters contains the default parameters that we start our
-	// liquidity manger with.
+	// liquidity manager with.
 	defaultParameters = Parameters{
 		AutoFeeBudget:   defaultBudget,
+		DestAddr:        nil,
 		MaxAutoInFlight: defaultMaxInFlight,
 		ChannelRules:    make(map[lnwire.ShortChannelID]*SwapRule),
 		PeerRules:       make(map[route.Vertex]*SwapRule),
@@ -37,6 +38,10 @@ type Parameters struct {
 	// Autoloop enables automatic dispatch of swaps.
 	Autoloop bool
 
+	// DestAddr is the address to be used for sweeping the on-chain HTLC that
+	// is related with a loop out.
+	DestAddr btcutil.Address
+
 	// AutoFeeBudget is the total amount we allow to be spent on
 	// automatically dispatched swaps. Once this budget has been used, we
 	// will stop dispatching swaps until the budget is increased or the
@@ -347,12 +352,25 @@ func rpcToParameters(req *clientrpc.LiquidityParameters) (*Parameters,
 		return nil, err
 	}
 
+	var destaddr btcutil.Address
+	if len(req.AutoloopDestAddress) != 0 {
+		if req.AutoloopDestAddress == "default" {
+			destaddr = nil
+		} else {
+			destaddr, err = btcutil.DecodeAddress(req.AutoloopDestAddress, nil)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
 	params := &Parameters{
 		FeeLimit:        feeLimit,
 		SweepConfTarget: req.SweepConfTarget,
 		FailureBackOff: time.Duration(req.FailureBackoffSec) *
 			time.Second,
 		Autoloop:        req.Autoloop,
+		DestAddr:        destaddr,
 		AutoFeeBudget:   btcutil.Amount(req.AutoloopBudgetSat),
 		MaxAutoInFlight: int(req.AutoMaxInFlight),
 		ChannelRules: make(

loopd/swapclient_server.go

@@ -747,12 +747,18 @@ func (s *swapClientServer) GetLiquidityParams(_ context.Context,
 
 	totalRules := len(cfg.ChannelRules) + len(cfg.PeerRules)
 
+	var destaddr string
+	if cfg.DestAddr != nil {
+		destaddr = cfg.DestAddr.String()
+	}
+
 	rpcCfg := &clientrpc.LiquidityParameters{
-		SweepConfTarget:   cfg.SweepConfTarget,
-		FailureBackoffSec: uint64(cfg.FailureBackOff.Seconds()),
-		Autoloop:          cfg.Autoloop,
-		AutoloopBudgetSat: uint64(cfg.AutoFeeBudget),
-		AutoMaxInFlight:   uint64(cfg.MaxAutoInFlight),
+		SweepConfTarget:     cfg.SweepConfTarget,
+		FailureBackoffSec:   uint64(cfg.FailureBackOff.Seconds()),
+		Autoloop:            cfg.Autoloop,
+		AutoloopBudgetSat:   uint64(cfg.AutoFeeBudget),
+		AutoMaxInFlight:     uint64(cfg.MaxAutoInFlight),
+		AutoloopDestAddress: destaddr,
 		Rules: make(
 			[]*clientrpc.LiquidityRule, 0, totalRules,
 		),