liquidity: add asset loop out unit test

Author: sputn1ck

liquidity/autoloop_test.go

@@ -1,6 +1,9 @@
 package liquidity
 
 import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
 	"testing"
 	"time"
 
@@ -11,6 +14,7 @@ import (
 	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/swap"
 	"github.com/lightninglabs/loop/test"
+	"github.com/lightninglabs/taproot-assets/rfqmsg"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
@@ -1520,3 +1524,141 @@ func existingInFromRequest(in *loop.LoopInRequest, initTime time.Time,
 		},
 	}
 }
+
+// TestEasyAssetAutoloop tests that the easy asset autoloop logic works as
+// expected. This involves testing that channels are correctly selected and
+// that the balance target is successfully met.
+func TestEasyAssetAutoloop(t *testing.T) {
+	defer test.Guard(t)
+
+	assetId := [32]byte{0x01}
+	assetStr := hex.EncodeToString(assetId[:])
+
+	// Decode a dummy p2wkh address to use as the destination address for
+	// the swaps.
+	addr, err := btcutil.DecodeAddress(p2wkhAddr, nil)
+	require.NoError(t, err)
+
+	customChanData1 := rfqmsg.JsonAssetChannel{
+		Assets: []rfqmsg.JsonAssetChanInfo{
+			{
+				AssetInfo: rfqmsg.JsonAssetUtxo{
+					AssetGenesis: rfqmsg.JsonAssetGenesis{
+						AssetID: assetStr,
+					},
+				},
+				LocalBalance:  950000,
+				RemoteBalance: 0,
+				Capacity:      100000,
+			},
+		},
+	}
+	customChanData1Bytes, err := json.Marshal(customChanData1)
+	require.NoError(t, err)
+
+	// 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.
+	assetChan := lndclient.ChannelInfo{
+		Active:            true,
+		ChannelID:         chanID1.ToUint64(),
+		PubKeyBytes:       peer1,
+		LocalBalance:      95000,
+		RemoteBalance:     0,
+		Capacity:          100000,
+		CustomChannelData: customChanData1Bytes,
+	}
+
+	// As the asset price func we'll just return a 1:1 conversion of asset units
+	// to satoshis.
+	assetPriceFunc := func(ctx context.Context, assetId string,
+		peerPubkey []byte, assetAmt uint64, minSatAmt btcutil.Amount) (
+		btcutil.Amount, error) {
+
+		return btcutil.Amount(assetAmt), nil
+	}
+
+	var (
+		channels = []lndclient.ChannelInfo{assetChan}
+
+		params = Parameters{
+			Autoloop:                  true,
+			DestAddr:                  addr,
+			AutoFeeBudget:             36000,
+			AutoFeeRefreshPeriod:      time.Hour * 3,
+			AutoloopBudgetLastRefresh: testBudgetStart,
+			MaxAutoInFlight:           2,
+			FailureBackOff:            time.Hour,
+			SweepConfTarget:           10,
+			HtlcConfTarget:            defaultHtlcConfTarget,
+			FeeLimit:                  defaultFeePortion(),
+			AssetAutoloopParams: map[string]AssetParams{
+				assetStr: {
+					EnableEasyOut:          true,
+					LocalTargetAssetAmount: 75000,
+				},
+			},
+		}
+	)
+
+	c := newAutoloopTestCtx(t, params, channels, testRestrictions)
+	// Return a fixed price for the asset.
+	c.manager.cfg.GetAssetPrice = assetPriceFunc
+
+	c.start()
+
+	var (
+		maxAmt = 50000
+
+		chan1Swap = &loop.OutRequest{
+			Amount:          btcutil.Amount(maxAmt),
+			DestAddr:        addr,
+			OutgoingChanSet: loopdb.ChannelSet{assetChan.ChannelID},
+			Label:           labels.AutoloopLabel(swap.TypeOut),
+			Initiator:       autoloopSwapInitiator,
+		}
+
+		quotesOut1 = []quoteRequestResp{
+			{
+				request: &loop.LoopOutQuoteRequest{
+					Amount: btcutil.Amount(maxAmt),
+					AssetRFQRequest: &loop.AssetRFQRequest{
+						AssetId:       assetId[:],
+						AssetEdgeNode: []byte("edge"),
+					},
+				},
+				quote: &loop.LoopOutQuote{
+					SwapFee:      1,
+					PrepayAmount: 1,
+					MinerFee:     1,
+					// We'll add a fake rfq info to use in the actual swap.
+					LoopOutRfq: &loop.LoopOutRfq{
+						PrepayRfqId: []byte("prepay"),
+						SwapRfqId:   []byte("swap"),
+					},
+				},
+			},
+		}
+
+		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()
+}