package liquidity import ( "testing" "time" "github.com/btcsuite/btcd/btcutil" "github.com/lightninglabs/lndclient" "github.com/lightninglabs/loop" "github.com/lightninglabs/loop/labels" "github.com/lightninglabs/loop/loopdb" "github.com/lightninglabs/loop/swap" "github.com/lightninglabs/loop/test" "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 // autoloop is not enabled. func TestAutoLoopDisabled(t *testing.T) { defer test.Guard(t)() // Set parameters for a channel that will require a swap. channels := []lndclient.ChannelInfo{ channel1, } params := defaultParameters params.AutoloopBudgetLastRefresh = testBudgetStart params.ChannelRules = map[lnwire.ShortChannelID]*SwapRule{ chanID1: chanRule, } c := newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() // We expect a single quote to be required for our swap on channel 1. // We set its quote to have acceptable fees for our current limit. quotes := []quoteRequestResp{ { request: &loop.LoopOutQuoteRequest{ Amount: chan1Rec.Amount, SweepConfTarget: chan1Rec.SweepConfTarget, }, quote: testQuote, }, } // Trigger an autoloop attempt for our test context with no existing // loop in/out swaps. We expect a swap for our channel to be suggested, // but do not expect any swaps to be executed, since autoloop is // disabled by default. step := &autoloopStep{ minAmt: 1, maxAmt: chan1Rec.Amount + 1, quotesOut: quotes, } c.autoloop(step) // Trigger another autoloop, this time setting our server restrictions // to have a minimum swap amount greater than the amount that we need // to swap. In this case we don't even expect to get a quote, because // our suggested swap is beneath the minimum swap size. step = &autoloopStep{ minAmt: chan1Rec.Amount + 1, maxAmt: chan1Rec.Amount + 2, } c.autoloop(step) c.stop() } // TestAutoLoopEnabled tests enabling the liquidity manger's autolooper. To keep // the test simple, we do not update actual lnd channel balances, but rather // run our mock with two channels that will always require a loop out according // to our rules. This allows us to test the other restrictions placed on the // autolooper (such as balance, and in-flight swaps) rather than need to worry // about calculating swap amounts and thresholds. func TestAutoLoopEnabled(t *testing.T) { defer test.Guard(t)() var ( channels = []lndclient.ChannelInfo{ channel1, channel2, } swapFeePPM uint64 = 1000 routeFeePPM uint64 = 1000 prepayFeePPM uint64 = 1000 prepayAmount = btcutil.Amount(20000) maxMiner = btcutil.Amount(20000) // Create a set of parameters with autoloop enabled. The // autoloop budget is set to allow exactly 2 swaps at the prices // that we set in our test quotes. params = Parameters{ Autoloop: true, AutoFeeBudget: 40066, AutoFeeRefreshPeriod: testBudgetRefresh, AutoloopBudgetLastRefresh: testBudgetStart, 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() // Calculate our maximum allowed fees and create quotes that fall within // our budget. var ( amt = chan1Rec.Amount maxSwapFee = ppmToSat(amt, swapFeePPM) // Create a quote that is within our limits. We do not set miner // fee because this value is not actually set by the server. 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, 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, 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}, }, }, } singleLoopOut = &loopdb.LoopOut{ Loop: loopdb.Loop{ Events: []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateSuccess, }, }, }, }, } ) // Tick our autolooper with no existing swaps, we expect a loop out // swap to be dispatched for each channel. step := &autoloopStep{ minAmt: 1, maxAmt: amt + 1, quotesOut: quotes, expectedOut: loopOuts, existingOutSingle: singleLoopOut, } c.autoloop(step) // Tick again with both of our swaps in progress. We haven't shifted our // channel balances at all, so swaps should still be suggested, but we // have 2 swaps in flight so we do not expect any suggestion. existing := []*loopdb.LoopOut{ existingSwapFromRequest(chan1Swap, testTime, nil), existingSwapFromRequest(chan2Swap, testTime, nil), } step = &autoloopStep{ minAmt: 1, maxAmt: amt + 1, existingOut: existing, existingOutSingle: singleLoopOut, } c.autoloop(step) // Now, we update our channel 2 swap to have failed due to off chain // failure and our first swap to have succeeded. now := c.testClock.Now() failedOffChain := []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateFailOffchainPayments, }, Time: now, }, } success := []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateSuccess, Cost: loopdb.SwapCost{ Server: quote1.SwapFee, Onchain: maxMiner, Offchain: maxRouteFee + chan1Rec.MaxPrepayRoutingFee, }, }, Time: now, }, } quotes = []quoteRequestResp{ { request: quoteRequest, quote: quote1, }, } loopOuts = []loopOutRequestResp{ { request: chan1Swap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{3}, }, }, } existing = []*loopdb.LoopOut{ existingSwapFromRequest(chan1Swap, testTime, success), existingSwapFromRequest(chan2Swap, testTime, failedOffChain), } // We tick again, this time we expect another swap on channel 1 (which // still has balances which reflect that we need to swap), but nothing // for channel 2, since it has had a failure. step = &autoloopStep{ minAmt: 1, maxAmt: amt + 1, existingOut: existing, quotesOut: quotes, expectedOut: loopOuts, existingOutSingle: singleLoopOut, } c.autoloop(step) // Now, we progress our time so that we have sufficiently backed off // for channel 2, and could perform another swap. c.testClock.SetTime(now.Add(params.FailureBackOff)) // Our existing swaps (1 successful, one pending) have used our budget // so we no longer expect any swaps to automatically dispatch. existing = []*loopdb.LoopOut{ existingSwapFromRequest(chan1Swap, testTime, success), existingSwapFromRequest(chan1Swap, c.testClock.Now(), nil), existingSwapFromRequest(chan2Swap, testTime, failedOffChain), } step = &autoloopStep{ minAmt: 1, maxAmt: amt + 1, existingOut: existing, quotesOut: quotes, existingOutSingle: singleLoopOut, } c.autoloop(step) 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, AutoFeeRefreshPeriod: testBudgetRefresh, AutoloopBudgetLastRefresh: testBudgetStart, 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}, }, }, } singleLoopOut = &loopdb.LoopOut{ Loop: loopdb.Loop{ Events: []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateSuccess, }, }, }, }, } ) step := &autoloopStep{ minAmt: 1, maxAmt: amt + 1, quotesOut: quotes, expectedOut: loopOuts, existingOutSingle: singleLoopOut, keepDestAddr: true, } 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) { defer test.Guard(t)() var ( // Setup our channels so that we have two channels with peer 2, // and a single channel with peer 1. channel3 = lndclient.ChannelInfo{ ChannelID: chanID3.ToUint64(), PubKeyBytes: peer2, LocalBalance: 10000, RemoteBalance: 0, Capacity: 10000, } channels = []lndclient.ChannelInfo{ channel1, channel2, channel3, } swapFeePPM uint64 = 1000 routeFeePPM uint64 = 1000 prepayFeePPM uint64 = 1000 prepayAmount = btcutil.Amount(20000) maxMiner = btcutil.Amount(20000) // Create a set of parameters with autoloop enabled, set our // budget to a value that will easily accommodate our two swaps. params = Parameters{ FeeLimit: NewFeeCategoryLimit( swapFeePPM, routeFeePPM, prepayFeePPM, maxMiner, prepayAmount, 20000, ), Autoloop: true, AutoFeeBudget: 100000, AutoFeeRefreshPeriod: testBudgetRefresh, AutoloopBudgetLastRefresh: testBudgetStart, MaxAutoInFlight: 2, FailureBackOff: time.Hour, SweepConfTarget: 10, ChannelRules: map[lnwire.ShortChannelID]*SwapRule{ chanID1: chanRule, }, PeerRules: map[route.Vertex]*SwapRule{ peer2: chanRule, }, HtlcConfTarget: defaultHtlcConfTarget, } ) c := newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() // Calculate our maximum allowed fees and create quotes that fall within // our budget. var ( // Create a quote for our peer level swap that is within // our budget, with an amount which would balance the peer /// across all of its channels. peerAmount = btcutil.Amount(15000) maxPeerSwapFee = ppmToSat(peerAmount, swapFeePPM) peerSwapQuote = &loop.LoopOutQuote{ SwapFee: maxPeerSwapFee, PrepayAmount: prepayAmount - 20, MinerFee: maxMiner - 10, } peerSwapQuoteRequest = &loop.LoopOutQuoteRequest{ Amount: peerAmount, SweepConfTarget: params.SweepConfTarget, } maxPeerRouteFee = ppmToSat(peerAmount, routeFeePPM) peerSwap = &loop.OutRequest{ Amount: peerAmount, MaxSwapRoutingFee: maxPeerRouteFee, MaxPrepayRoutingFee: ppmToSat( peerSwapQuote.PrepayAmount, routeFeePPM, ), MaxSwapFee: peerSwapQuote.SwapFee, MaxPrepayAmount: peerSwapQuote.PrepayAmount, MaxMinerFee: maxMiner, SweepConfTarget: params.SweepConfTarget, OutgoingChanSet: loopdb.ChannelSet{ chanID2.ToUint64(), chanID3.ToUint64(), }, Label: labels.AutoloopLabel(swap.TypeOut), Initiator: autoloopSwapInitiator, } // Create a quote for our single channel swap that is within // our budget. chanAmount = chan1Rec.Amount maxChanSwapFee = ppmToSat(chanAmount, swapFeePPM) channelSwapQuote = &loop.LoopOutQuote{ SwapFee: maxChanSwapFee, PrepayAmount: prepayAmount - 10, MinerFee: maxMiner - 10, } chanSwapQuoteRequest = &loop.LoopOutQuoteRequest{ Amount: chanAmount, SweepConfTarget: params.SweepConfTarget, } maxChanRouteFee = ppmToSat(chanAmount, routeFeePPM) chanSwap = &loop.OutRequest{ Amount: chanAmount, MaxSwapRoutingFee: maxChanRouteFee, MaxPrepayRoutingFee: ppmToSat( channelSwapQuote.PrepayAmount, routeFeePPM, ), MaxSwapFee: channelSwapQuote.SwapFee, MaxPrepayAmount: channelSwapQuote.PrepayAmount, MaxMinerFee: maxMiner, SweepConfTarget: params.SweepConfTarget, OutgoingChanSet: loopdb.ChannelSet{chanID1.ToUint64()}, Label: labels.AutoloopLabel(swap.TypeOut), Initiator: autoloopSwapInitiator, } quotes = []quoteRequestResp{ { request: peerSwapQuoteRequest, quote: peerSwapQuote, }, { request: chanSwapQuoteRequest, quote: channelSwapQuote, }, } loopOuts = []loopOutRequestResp{ { request: peerSwap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{2}, }, }, { request: chanSwap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, } singleLoopOut = &loopdb.LoopOut{ Loop: loopdb.Loop{ Events: []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateSuccess, }, }, }, }, } ) // Tick our autolooper with no existing swaps, we expect a loop out // swap to be dispatched for each of our rules. We set our server side // maximum to be greater than the swap amount for our peer swap (which // is the larger of the two swaps). step := &autoloopStep{ minAmt: 1, maxAmt: peerAmount + 1, quotesOut: quotes, expectedOut: loopOuts, existingOutSingle: singleLoopOut, } c.autoloop(step) c.stop() } // TestAutoLoopInEnabled tests dispatch of autoloop in swaps. func TestAutoLoopInEnabled(t *testing.T) { defer test.Guard(t)() var ( chan1 = lndclient.ChannelInfo{ ChannelID: chanID1.ToUint64(), PubKeyBytes: peer1, Capacity: 100000, RemoteBalance: 100000, LocalBalance: 0, } chan2 = lndclient.ChannelInfo{ ChannelID: chanID2.ToUint64(), PubKeyBytes: peer2, Capacity: 200000, RemoteBalance: 200000, LocalBalance: 0, } channels = []lndclient.ChannelInfo{ chan1, chan2, } // Create a rule which will loop in, with no inbound liquidity // reserve. rule = &SwapRule{ ThresholdRule: NewThresholdRule(0, 60), Type: swap.TypeIn, } // Under these rules, we'll have the following recommended // swaps: peer1ExpectedAmt btcutil.Amount = 80000 peer2ExpectedAmt btcutil.Amount = 160000 // Set our per-swap budget to 5% of swap amount. swapFeePPM uint64 = 50000 htlcConfTarget int32 = 10 // Calculate the maximum amount we'll pay for each swap and // set our budget to be able to accommodate both. peer1MaxFee = ppmToSat(peer1ExpectedAmt, swapFeePPM) peer2MaxFee = ppmToSat(peer2ExpectedAmt, swapFeePPM) params = Parameters{ Autoloop: true, AutoFeeBudget: peer1MaxFee + peer2MaxFee + 1, AutoFeeRefreshPeriod: testBudgetRefresh, AutoloopBudgetLastRefresh: testBudgetStart, MaxAutoInFlight: 2, FailureBackOff: time.Hour, FeeLimit: NewFeePortion(swapFeePPM), ChannelRules: make(map[lnwire.ShortChannelID]*SwapRule), PeerRules: map[route.Vertex]*SwapRule{ peer1: rule, peer2: rule, }, HtlcConfTarget: htlcConfTarget, SweepConfTarget: loop.DefaultSweepConfTarget, } ) c := newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() // Calculate our maximum allowed fees and create quotes that fall within // our budget. var ( quote1 = &loop.LoopInQuote{ SwapFee: peer1MaxFee / 4, MinerFee: peer1MaxFee / 8, } quote2Unaffordable = &loop.LoopInQuote{ SwapFee: peer2MaxFee * 2, MinerFee: peer2MaxFee * 2, } quoteRequest1 = &loop.LoopInQuoteRequest{ Amount: peer1ExpectedAmt, HtlcConfTarget: htlcConfTarget, LastHop: &peer1, } quoteRequest2 = &loop.LoopInQuoteRequest{ Amount: peer2ExpectedAmt, HtlcConfTarget: htlcConfTarget, LastHop: &peer2, } peer1Swap = &loop.LoopInRequest{ Amount: peer1ExpectedAmt, MaxSwapFee: quote1.SwapFee, MaxMinerFee: quote1.MinerFee, HtlcConfTarget: htlcConfTarget, LastHop: &peer1, ExternalHtlc: false, Label: labels.AutoloopLabel(swap.TypeIn), Initiator: autoloopSwapInitiator, } ) // Tick our autolooper with no existing swaps. Both of our peers // require swaps, but one of our peer's quotes is too expensive. step := &autoloopStep{ minAmt: 1, maxAmt: peer2ExpectedAmt + 1, quotesIn: []quoteInRequestResp{ { request: quoteRequest1, quote: quote1, }, { request: quoteRequest2, quote: quote2Unaffordable, }, }, expectedIn: []loopInRequestResp{ { request: peer1Swap, response: &loop.LoopInSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, }, } c.autoloop(step) // Now, we tick again with our first swap in progress. This time, we // provide a quote for our second swap which is more affordable, so we // expect it to be dispatched. var ( quote2Affordable = &loop.LoopInQuote{ SwapFee: peer2MaxFee / 8, MinerFee: peer2MaxFee / 2, } peer2Swap = &loop.LoopInRequest{ Amount: peer2ExpectedAmt, MaxSwapFee: quote2Affordable.SwapFee, MaxMinerFee: quote2Affordable.MinerFee, HtlcConfTarget: htlcConfTarget, LastHop: &peer2, ExternalHtlc: false, Label: labels.AutoloopLabel(swap.TypeIn), Initiator: autoloopSwapInitiator, } existing = []*loopdb.LoopIn{ existingInFromRequest(peer1Swap, testTime, nil), } ) step = &autoloopStep{ minAmt: 1, maxAmt: peer2ExpectedAmt + 1, quotesIn: []quoteInRequestResp{ { request: quoteRequest2, quote: quote2Affordable, }, }, existingIn: existing, expectedIn: []loopInRequestResp{ { request: peer2Swap, response: &loop.LoopInSwapInfo{ SwapHash: lntypes.Hash{2}, }, }, }, } c.autoloop(step) c.stop() } // TestAutoloopBothTypes tests dispatching of a loop out and loop in swap at the // same time. func TestAutoloopBothTypes(t *testing.T) { defer test.Guard(t)() var ( chan1 = lndclient.ChannelInfo{ ChannelID: chanID1.ToUint64(), PubKeyBytes: peer1, Capacity: 1000000, LocalBalance: 1000000, } chan2 = lndclient.ChannelInfo{ ChannelID: chanID2.ToUint64(), PubKeyBytes: peer2, Capacity: 200000, RemoteBalance: 200000, LocalBalance: 0, } channels = []lndclient.ChannelInfo{ chan1, chan2, } // Create a rule which will loop out, with no outbound liquidity // reserve. outRule = &SwapRule{ ThresholdRule: NewThresholdRule(40, 0), Type: swap.TypeOut, } // Create a rule which will loop in, with no inbound liquidity // reserve. inRule = &SwapRule{ ThresholdRule: NewThresholdRule(0, 60), Type: swap.TypeIn, } // Under this rule, we expect a loop in swap. loopOutAmt btcutil.Amount = 700000 loopInAmount btcutil.Amount = 160000 // Set our per-swap budget to 5% of swap amount. swapFeePPM uint64 = 50000 htlcConfTarget int32 = 10 // Calculate the maximum amount we'll pay for our loop in. loopOutMaxFee = ppmToSat(loopOutAmt, swapFeePPM) loopInMaxFee = ppmToSat(loopInAmount, swapFeePPM) params = Parameters{ Autoloop: true, AutoFeeBudget: loopOutMaxFee + loopInMaxFee + 1, AutoFeeRefreshPeriod: testBudgetRefresh, AutoloopBudgetLastRefresh: testBudgetStart, MaxAutoInFlight: 2, FailureBackOff: time.Hour, FeeLimit: NewFeePortion(swapFeePPM), ChannelRules: map[lnwire.ShortChannelID]*SwapRule{ chanID1: outRule, }, PeerRules: map[route.Vertex]*SwapRule{ peer2: inRule, }, HtlcConfTarget: htlcConfTarget, SweepConfTarget: loop.DefaultSweepConfTarget, } ) c := newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() // Calculate our maximum allowed fees and create quotes that fall within // our budget. var ( loopOutQuote = &loop.LoopOutQuote{ SwapFee: loopOutMaxFee / 4, PrepayAmount: loopOutMaxFee / 4, } loopOutQuoteReq = &loop.LoopOutQuoteRequest{ Amount: loopOutAmt, SweepConfTarget: params.SweepConfTarget, SwapPublicationDeadline: testTime, } prepayMaxFee, routeMaxFee, minerFee = params.FeeLimit.loopOutFees( loopOutAmt, loopOutQuote, ) loopOutSwap = &loop.OutRequest{ Amount: loopOutAmt, MaxSwapRoutingFee: routeMaxFee, MaxPrepayRoutingFee: prepayMaxFee, MaxSwapFee: loopOutQuote.SwapFee, MaxPrepayAmount: loopOutQuote.PrepayAmount, MaxMinerFee: minerFee, SweepConfTarget: params.SweepConfTarget, OutgoingChanSet: loopdb.ChannelSet{ chanID1.ToUint64(), }, Label: labels.AutoloopLabel(swap.TypeOut), Initiator: autoloopSwapInitiator, } loopinQuote = &loop.LoopInQuote{ SwapFee: loopInMaxFee / 4, MinerFee: loopInMaxFee / 8, } loopInQuoteReq = &loop.LoopInQuoteRequest{ Amount: loopInAmount, HtlcConfTarget: htlcConfTarget, LastHop: &peer2, } loopInSwap = &loop.LoopInRequest{ Amount: loopInAmount, MaxSwapFee: loopinQuote.SwapFee, MaxMinerFee: loopinQuote.MinerFee, HtlcConfTarget: htlcConfTarget, LastHop: &peer2, ExternalHtlc: false, Label: labels.AutoloopLabel(swap.TypeIn), Initiator: autoloopSwapInitiator, } singleLoopOut = &loopdb.LoopOut{ Loop: loopdb.Loop{ Events: []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.SwapState(loopdb.StateSuccess), }, }, }, }, } ) step := &autoloopStep{ minAmt: 1, maxAmt: loopOutAmt + 1, quotesOut: []quoteRequestResp{ { request: loopOutQuoteReq, quote: loopOutQuote, }, }, quotesIn: []quoteInRequestResp{ { request: loopInQuoteReq, quote: loopinQuote, }, }, expectedOut: []loopOutRequestResp{ { request: loopOutSwap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, }, expectedIn: []loopInRequestResp{ { request: loopInSwap, response: &loop.LoopInSwapInfo{ SwapHash: lntypes.Hash{2}, }, }, }, existingOutSingle: singleLoopOut, } c.autoloop(step) c.stop() } // TestAutoLoopRecurringBudget tests that the autolooper will perform swaps that // respect the fee budget, and that it will refresh the budget based on the // defined refresh period. func TestAutoLoopRecurringBudget(t *testing.T) { defer test.Guard(t)() var ( channels = []lndclient.ChannelInfo{ channel1, channel2, } swapFeePPM uint64 = 1000 routeFeePPM uint64 = 1000 prepayFeePPM uint64 = 1000 prepayAmount = btcutil.Amount(20000) maxMiner = btcutil.Amount(20000) params = Parameters{ Autoloop: true, AutoFeeBudget: 36000, AutoFeeRefreshPeriod: time.Hour * 3, AutoloopBudgetLastRefresh: testBudgetStart, 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() // Calculate our maximum allowed fees and create quotes that fall within // our budget. var ( amt = chan1Rec.Amount maxSwapFee = ppmToSat(amt, swapFeePPM) // Create a quote that is within our limits. We do not set miner // fee because this value is not actually set by the server. 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, } quotes1 = []quoteRequestResp{ { request: quoteRequest, quote: quote1, }, { request: quoteRequest, quote: quote2, }, } quotes2 = []quoteRequestResp{ { request: quoteRequest, quote: quote2, }, } maxRouteFee = ppmToSat(amt, routeFeePPM) chan1Swap = &loop.OutRequest{ Amount: amt, 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, 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, } loopOuts1 = []loopOutRequestResp{ { request: chan1Swap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, } loopOuts2 = []loopOutRequestResp{ { request: chan2Swap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, } singleLoopOut = &loopdb.LoopOut{ Loop: loopdb.Loop{ Events: []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.SwapState(loopdb.StateSuccess), }, }, }, }, } ) // Tick our autolooper with no existing swaps, we expect a loop out // swap to be dispatched on first channel. step := &autoloopStep{ minAmt: 1, maxAmt: amt + 1, quotesOut: quotes1, expectedOut: loopOuts1, existingOutSingle: singleLoopOut, } c.autoloop(step) existing := []*loopdb.LoopOut{ existingSwapFromRequest( chan1Swap, testTime, []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateInitiated, }, Time: testTime, }, }, ), } step = &autoloopStep{ minAmt: 1, maxAmt: amt + 1, quotesOut: quotes2, existingOut: existing, expectedOut: nil, existingOutSingle: singleLoopOut, } // Tick again, we should expect no loop outs because our budget would be // exceeded. c.autoloop(step) // Create the existing entry for the first swap, marking its last update // with success and a specific timestamp. existing2 := []*loopdb.LoopOut{ existingSwapFromRequest( chan1Swap, testTime, []*loopdb.LoopEvent{ { SwapStateData: loopdb.SwapStateData{ State: loopdb.StateSuccess, }, Time: testTime, }, }, ), } // Apply the balance shifts on the channels in order to get the correct // recommendations on next tick. c.lnd.Channels[0].LocalBalance = 2500 c.lnd.Channels[0].RemoteBalance = 7500 // Advance time to the future, causing a budget refresh. c.testClock.SetTime(testTime.Add(time.Hour * 25)) step = &autoloopStep{ minAmt: 1, maxAmt: amt + 1, quotesOut: quotes2, existingOut: existing2, expectedOut: loopOuts2, existingOutSingle: singleLoopOut, } // Tick again, we should expect a loop out to occur on the 2nd channel. c.autoloop(step) c.stop() } // TestEasyAutoloop tests that the easy autoloop logic works as expected. This // involves testing that channels are correctly selected and that the balance // target is successfully met. func TestEasyAutoloop(t *testing.T) { defer test.Guard(t) // We need to change the default channels we use for tests so that they // have different local balances in order to know which one is going to // be selected by easy autoloop. easyChannel1 := lndclient.ChannelInfo{ Active: true, ChannelID: chanID1.ToUint64(), PubKeyBytes: peer1, LocalBalance: 95000, RemoteBalance: 0, Capacity: 100000, } easyChannel2 := lndclient.ChannelInfo{ Active: true, ChannelID: chanID1.ToUint64(), PubKeyBytes: peer1, LocalBalance: 75000, RemoteBalance: 0, Capacity: 100000, } var ( channels = []lndclient.ChannelInfo{ easyChannel1, easyChannel2, } params = Parameters{ Autoloop: true, AutoFeeBudget: 36000, AutoFeeRefreshPeriod: time.Hour * 3, AutoloopBudgetLastRefresh: testBudgetStart, MaxAutoInFlight: 2, FailureBackOff: time.Hour, SweepConfTarget: 10, HtlcConfTarget: defaultHtlcConfTarget, EasyAutoloop: true, EasyAutoloopTarget: 75000, FeeLimit: defaultFeePortion(), } ) c := newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() var ( maxAmt = 50000 chan1Swap = &loop.OutRequest{ Amount: btcutil.Amount(maxAmt), OutgoingChanSet: loopdb.ChannelSet{easyChannel1.ChannelID}, Label: labels.AutoloopLabel(swap.TypeOut), Initiator: autoloopSwapInitiator, } quotesOut1 = []quoteRequestResp{ { request: &loop.LoopOutQuoteRequest{ Amount: btcutil.Amount(maxAmt), }, quote: &loop.LoopOutQuote{ SwapFee: 1, PrepayAmount: 1, MinerFee: 1, }, }, } loopOut1 = []loopOutRequestResp{ { request: chan1Swap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, } ) // We expected one max size swap to be dispatched on our channel with // the biggest local balance. step := &easyAutoloopStep{ minAmt: 1, maxAmt: 50000, quotesOut: quotesOut1, expectedOut: loopOut1, } c.easyautoloop(step, false) c.stop() // In order to reflect the change on the channel balances we create a // new context and restart the autolooper. easyChannel1.LocalBalance -= chan1Swap.Amount channels = []lndclient.ChannelInfo{ easyChannel1, easyChannel2, } c = newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() var ( amt2 = 45_000 chan2Swap = &loop.OutRequest{ Amount: btcutil.Amount(amt2), OutgoingChanSet: loopdb.ChannelSet{easyChannel2.ChannelID}, Label: labels.AutoloopLabel(swap.TypeOut), Initiator: autoloopSwapInitiator, } quotesOut2 = []quoteRequestResp{ { request: &loop.LoopOutQuoteRequest{ Amount: btcutil.Amount(amt2), }, quote: &loop.LoopOutQuote{ SwapFee: 1, PrepayAmount: 1, MinerFee: 1, }, }, } loopOut2 = []loopOutRequestResp{ { request: chan2Swap, response: &loop.LoopOutSwapInfo{ SwapHash: lntypes.Hash{1}, }, }, } ) // We expect a swap of size 45_000 to be dispatched in order to meet the // defined target of 75_000. step = &easyAutoloopStep{ minAmt: 1, maxAmt: 50000, quotesOut: quotesOut2, expectedOut: loopOut2, } c.easyautoloop(step, false) c.stop() // In order to reflect the change on the channel balances we create a // new context and restart the autolooper. easyChannel2.LocalBalance -= btcutil.Amount(amt2) channels = []lndclient.ChannelInfo{ easyChannel1, easyChannel2, } c = newAutoloopTestCtx(t, params, channels, testRestrictions) c.start() // We have met the target of 75_000 so we don't expect any action from // easy autoloop. That's why we set noop to true in the call below. step = &easyAutoloopStep{ minAmt: 1, maxAmt: 50000, } c.easyautoloop(step, true) c.stop() } // existingSwapFromRequest is a helper function which returns the db // representation of a loop out request with the event set provided. func existingSwapFromRequest(request *loop.OutRequest, initTime time.Time, events []*loopdb.LoopEvent) *loopdb.LoopOut { return &loopdb.LoopOut{ Loop: loopdb.Loop{ Events: events, }, Contract: &loopdb.LoopOutContract{ SwapContract: loopdb.SwapContract{ AmountRequested: request.Amount, MaxSwapFee: request.MaxSwapFee, MaxMinerFee: request.MaxMinerFee, InitiationTime: initTime, Label: request.Label, }, SwapInvoice: "", MaxSwapRoutingFee: request.MaxSwapRoutingFee, SweepConfTarget: request.SweepConfTarget, OutgoingChanSet: request.OutgoingChanSet, MaxPrepayRoutingFee: request.MaxSwapRoutingFee, }, } } func existingInFromRequest(in *loop.LoopInRequest, initTime time.Time, events []*loopdb.LoopEvent) *loopdb.LoopIn { return &loopdb.LoopIn{ Loop: loopdb.Loop{ Events: events, }, Contract: &loopdb.LoopInContract{ SwapContract: loopdb.SwapContract{ MaxSwapFee: in.MaxSwapFee, MaxMinerFee: in.MaxMinerFee, InitiationTime: initTime, Label: in.Label, }, HtlcConfTarget: in.HtlcConfTarget, LastHop: in.LastHop, ExternalHtlc: in.ExternalHtlc, }, } }