mirror of
https://github.com/lightninglabs/loop
synced 2024-11-11 13:11:12 +00:00
502e47362c
This commit adds a peer listing function to our generic swap interface, which we will use to set reasons for swaps that are specified by peer pubkey rather than channel.
105 lines
3.0 KiB
Go
105 lines
3.0 KiB
Go
package liquidity
|
|
|
|
import (
|
|
"github.com/btcsuite/btcutil"
|
|
"github.com/lightninglabs/loop"
|
|
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/lightningnetwork/lnd/routing/route"
|
|
)
|
|
|
|
// FeeLimit is an interface implemented by different strategies for limiting
|
|
// the fees we pay for autoloops.
|
|
type FeeLimit interface {
|
|
// String returns the string representation of fee limits.
|
|
String() string
|
|
|
|
// validate returns an error if the values provided are invalid.
|
|
validate() error
|
|
|
|
// mayLoopOut checks whether we may dispatch a loop out swap based on
|
|
// the current fee conditions.
|
|
mayLoopOut(estimate chainfee.SatPerKWeight) error
|
|
|
|
// loopOutLimits checks whether the quote provided is within our fee
|
|
// limits for the swap amount.
|
|
loopOutLimits(amount btcutil.Amount, quote *loop.LoopOutQuote) error
|
|
|
|
// loopOutFees return the maximum prepay and invoice routing fees for
|
|
// a swap amount and quote.
|
|
loopOutFees(amount btcutil.Amount, quote *loop.LoopOutQuote) (
|
|
btcutil.Amount, btcutil.Amount, btcutil.Amount)
|
|
}
|
|
|
|
// swapSuggestion is an interface implemented by suggested swaps for our
|
|
// different swap types. This interface is used to allow us to handle different
|
|
// swap types with the same autoloop logic.
|
|
type swapSuggestion interface {
|
|
// fees returns the highest possible fee amount we could pay for a swap
|
|
// in satoshis.
|
|
fees() btcutil.Amount
|
|
|
|
// amount returns the swap amount in satoshis.
|
|
amount() btcutil.Amount
|
|
|
|
// channels returns the set of channels involved in the swap.
|
|
channels() []lnwire.ShortChannelID
|
|
|
|
// peers returns the set of peers involved in the swap, taking a map
|
|
// of known channel IDs to peers as an argument so that channel peers
|
|
// can be looked up.
|
|
peers(knownChans map[uint64]route.Vertex) []route.Vertex
|
|
}
|
|
|
|
// Compile-time assertion that loopOutSwapSuggestion satisfies the
|
|
// swapSuggestion interface.
|
|
var _ swapSuggestion = (*loopOutSwapSuggestion)(nil)
|
|
|
|
type loopOutSwapSuggestion struct {
|
|
loop.OutRequest
|
|
}
|
|
|
|
func (l *loopOutSwapSuggestion) amount() btcutil.Amount {
|
|
return l.Amount
|
|
}
|
|
|
|
func (l *loopOutSwapSuggestion) fees() btcutil.Amount {
|
|
return worstCaseOutFees(
|
|
l.MaxPrepayRoutingFee, l.MaxSwapRoutingFee, l.MaxSwapFee,
|
|
l.MaxMinerFee, l.MaxPrepayAmount,
|
|
)
|
|
}
|
|
|
|
func (l *loopOutSwapSuggestion) channels() []lnwire.ShortChannelID {
|
|
channels := make([]lnwire.ShortChannelID, len(l.OutgoingChanSet))
|
|
|
|
for i, id := range l.OutgoingChanSet {
|
|
channels[i] = lnwire.NewShortChanIDFromInt(id)
|
|
}
|
|
|
|
return channels
|
|
}
|
|
|
|
// peers returns the set of peers that the loop out swap is restricted to.
|
|
func (l *loopOutSwapSuggestion) peers(
|
|
knownChans map[uint64]route.Vertex) []route.Vertex {
|
|
|
|
peers := make(map[route.Vertex]struct{}, len(knownChans))
|
|
|
|
for _, channel := range l.OutgoingChanSet {
|
|
peer, ok := knownChans[channel]
|
|
if !ok {
|
|
log.Warnf("peer for channel: %v unknown", channel)
|
|
}
|
|
|
|
peers[peer] = struct{}{}
|
|
}
|
|
|
|
peerList := make([]route.Vertex, 0, len(peers))
|
|
for peer := range peers {
|
|
peerList = append(peerList, peer)
|
|
}
|
|
|
|
return peerList
|
|
}
|