liquidity: add easy asset autoloop out

Author: sputn1ck

liquidity/liquidity.go

@@ -34,6 +34,7 @@ package liquidity
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math"
@@ -48,6 +49,7 @@ import (
 	"github.com/lightninglabs/loop/loopdb"
 	clientrpc "github.com/lightninglabs/loop/looprpc"
 	"github.com/lightninglabs/loop/swap"
+	"github.com/lightninglabs/taproot-assets/rfqmsg"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/funding"
 	"github.com/lightningnetwork/lnd/lntypes"
@@ -218,6 +220,10 @@ type Config struct {
 	LoopOutTerms func(ctx context.Context,
 		initiator string) (*loop.LoopOutTerms, error)
 
+	// GetAssetPrice returns the price of an asset in satoshis.
+	GetAssetPrice func(ctx context.Context, assetId string,
+		assetAmt, minSatAmt uint64) (btcutil.Amount, error)
+
 	// Clock allows easy mocking of time in unit tests.
 	Clock clock.Clock
 
@@ -305,6 +311,15 @@ func (m *Manager) Run(ctx context.Context) error {
 				}
 			}
 
+			for assetID := range m.params.AssetAutoloopParams {
+				err = m.easyAutoLoopAsset(ctx, assetID)
+				if err != nil {
+					log.Errorf("easy autoloop asset "+
+						"failed: id: %v, err: %v",
+						assetID, err)
+				}
+			}
+
 		case <-ctx.Done():
 			return ctx.Err()
 		}
@@ -501,7 +516,41 @@ func (m *Manager) easyAutoLoop(ctx context.Context) error {
 	m.refreshAutoloopBudget(ctx)
 
 	// Dispatch the best easy autoloop swap.
-	err := m.dispatchBestEasyAutoloopSwap(ctx)
+	err := m.dispatchBestEasyAutoloopSwap(
+		ctx, "", m.params.EasyAutoloopTarget,
+	)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// easyAutoLoopAsset is the main entry point for the easy auto loop functionality
+// for assets. This function will try to dispatch a swap in order to meet the
+// easy autoloop requirements for the given asset. For easyAutoloop to work
+// there needs to be an EasyAutoloopTarget defined in the parameters. Easy
+// autoloop also uses the configured max inflight swaps and budget rules defined
+// in the parameters.
+func (m *Manager) easyAutoLoopAsset(ctx context.Context, assetID string) error {
+	assetParams, ok := m.params.AssetAutoloopParams[assetID]
+	if !ok {
+		return nil
+	}
+
+	if !assetParams.EnableEasyOut {
+		return nil
+	}
+
+	// First check if we should refresh our budget before calculating any
+	// swaps for autoloop.
+	m.refreshAutoloopBudget(ctx)
+
+	// Dispatch the best easy autoloop swap.
+	err := m.dispatchBestEasyAutoloopSwap(
+		ctx, assetID,
+		btcutil.Amount(assetParams.EasyAutoloopTargetAmount),
+	)
 	if err != nil {
 		return err
 	}
@@ -522,7 +571,9 @@ func (m *Manager) ForceAutoLoop(ctx context.Context) error {
 
 // dispatchBestEasyAutoloopSwap tries to dispatch a swap to bring the total
 // local balance back to the target.
-func (m *Manager) dispatchBestEasyAutoloopSwap(ctx context.Context) error {
+func (m *Manager) dispatchBestEasyAutoloopSwap(ctx context.Context,
+	assetID string, localTarget btcutil.Amount) error {
+
 	// Retrieve existing swaps.
 	loopOut, err := m.cfg.ListLoopOut(ctx)
 	if err != nil {
@@ -557,16 +608,30 @@ func (m *Manager) dispatchBestEasyAutoloopSwap(ctx context.Context) error {
 	localTotal := btcutil.Amount(0)
 	for _, channel := range channels {
 		if channelIsCustom(channel) {
-			continue
+			if assetID == "" {
+				continue
+			}
+			assetData := getCustomAssetData(channel, assetID)
+
+			if assetData == nil {
+				continue
+			}
+			// We'll overwrite the channel local balance to be
+			// the custom asset balance. This allows us to make
+			// use of existing logic.
+			channel.LocalBalance = btcutil.Amount(
+				assetData.LocalBalance,
+			)
 		}
+
 		localTotal += channel.LocalBalance
 	}
 
 	// Since we're only autolooping-out we need to check if we are below
 	// the target, meaning that we already meet the requirements.
-	if localTotal <= m.params.EasyAutoloopTarget {
+	if localTotal <= localTarget {
 		log.Debugf("total local balance %v below target %v",
-			localTotal, m.params.EasyAutoloopTarget)
+			localTotal, localTarget)
 		return nil
 	}
 
@@ -579,23 +644,37 @@ func (m *Manager) dispatchBestEasyAutoloopSwap(ctx context.Context) error {
 
 	// Calculate the amount that we want to loop out. If it exceeds the max
 	// allowed clamp it to max.
-	amount := localTotal - m.params.EasyAutoloopTarget
-	if amount > restrictions.Maximum {
-		amount = restrictions.Maximum
+	amount := localTotal - localTarget
+	satAmount := amount
+
+	// If we run a custom asset, we'll need to convert the asset amount
+	// we want to swap to the satoshi amount.
+	if assetID != "" {
+		satAmount, err = m.cfg.GetAssetPrice(
+			ctx, assetID, uint64(amount),
+			uint64(restrictions.Minimum),
+		)
+		if err != nil {
+			return err
+		}
+	}
+
+	if satAmount > restrictions.Maximum {
+		satAmount = restrictions.Maximum
 	}
 
 	// If the amount we want to loop out is less than the minimum we can't
 	// proceed with a swap, so we return early.
-	if amount < restrictions.Minimum {
+	if satAmount < restrictions.Minimum {
 		log.Debugf("easy autoloop: swap amount is below minimum swap "+
 			"size, minimum=%v, need to swap %v",
-			restrictions.Minimum, amount)
+			restrictions.Minimum, satAmount)
 		return nil
 	}
 
 	log.Debugf("easy autoloop: local_total=%v, target=%v, "+
 		"attempting to loop out %v", localTotal,
-		m.params.EasyAutoloopTarget, amount)
+		localTarget, amount)
 
 	// Start building that swap.
 	builder := newLoopOutBuilder(m.cfg)
@@ -611,7 +690,7 @@ func (m *Manager) dispatchBestEasyAutoloopSwap(ctx context.Context) error {
 		channel.ChannelID, channel.LocalBalance)
 
 	swapAmt, err := btcutil.NewAmount(
-		math.Min(channel.LocalBalance.ToBTC(), amount.ToBTC()),
+		math.Min(channel.LocalBalance.ToBTC(), satAmount.ToBTC()),
 	)
 	if err != nil {
 		return err
@@ -639,9 +718,17 @@ func (m *Manager) dispatchBestEasyAutoloopSwap(ctx context.Context) error {
 		lnwire.NewShortChanIDFromInt(channel.ChannelID),
 	}
 
+	var assetSwap *assetSwapInfo
+	if assetID != "" {
+		assetSwap = &assetSwapInfo{
+			assetID:    assetID,
+			peerPubkey: channel.PubKeyBytes[:],
+		}
+	}
+
 	suggestion, err := builder.buildSwap(
 		ctx, channel.PubKeyBytes, outgoing, swapAmt, easyParams,
-		nil,
+		assetSwap,
 	)
 	if err != nil {
 		return err
@@ -1441,10 +1528,6 @@ func (m *Manager) pickEasyAutoloopChannel(channels []lndclient.ChannelInfo,
 	// Check each channel, since channels are already sorted we return the
 	// first channel that passes all checks.
 	for _, channel := range channels {
-		if channelIsCustom(channel) {
-			continue
-		}
-
 		shortChanID := lnwire.NewShortChanIDFromInt(channel.ChannelID)
 
 		if !channel.Active {
@@ -1467,7 +1550,12 @@ func (m *Manager) pickEasyAutoloopChannel(channels []lndclient.ChannelInfo,
 			continue
 		}
 
-		if channel.LocalBalance < restrictions.Minimum {
+		if channel.LocalBalance < restrictions.Minimum &&
+			// If we use a custom channel, the local balance is
+			// denominated in the asset's unit, so we don't need to
+			// check the minimum.
+			!channelIsCustom(channel) {
+
 			log.Debugf("Channel %v cannot be used for easy "+
 				"autoloop: insufficient local balance %v,"+
 				"minimum is %v, skipping remaining channels",
@@ -1578,3 +1666,27 @@ func channelIsCustom(channel lndclient.ChannelInfo) bool {
 	// don't want to consider it for swaps.
 	return channel.CustomChannelData != nil
 }
+
+// getCustomAssetData returns the asset data for a custom channel.
+func getCustomAssetData(channel lndclient.ChannelInfo, assetID string,
+) *rfqmsg.JsonAssetChanInfo {
+
+	if channel.CustomChannelData == nil {
+		return nil
+	}
+
+	var assetData rfqmsg.JsonAssetChannel
+	err := json.Unmarshal(channel.CustomChannelData, &assetData)
+	if err != nil {
+		log.Errorf("Error unmarshalling custom channel data: %v", err)
+		return nil
+	}
+
+	for _, asset := range assetData.Assets {
+		if asset.AssetInfo.AssetGenesis.AssetID == assetID {
+			return &asset
+		}
+	}
+
+	return nil
+}