|
|
|
|
@ -1,6 +1,7 @@
|
|
|
|
|
package loop
|
|
|
|
|
|
|
|
|
|
import (
|
|
|
|
|
"bytes"
|
|
|
|
|
"context"
|
|
|
|
|
"fmt"
|
|
|
|
|
"strconv"
|
|
|
|
|
@ -12,7 +13,6 @@ import (
|
|
|
|
|
"github.com/btcsuite/btcd/wire"
|
|
|
|
|
"github.com/lightninglabs/lndclient"
|
|
|
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
|
|
|
"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
|
|
|
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
|
|
|
"github.com/lightningnetwork/lnd/routing/route"
|
|
|
|
|
"github.com/lightningnetwork/lnd/zpay32"
|
|
|
|
|
@ -21,6 +21,11 @@ import (
|
|
|
|
|
var (
|
|
|
|
|
// DefaultMaxHopHints is set to 20 as that is the default set in LND.
|
|
|
|
|
DefaultMaxHopHints = 20
|
|
|
|
|
|
|
|
|
|
// hopHintFactor is factor by which we scale the total amount of
|
|
|
|
|
// inbound capacity we want our hop hints to represent, allowing us to
|
|
|
|
|
// have some leeway if peers go offline.
|
|
|
|
|
hopHintFactor = 2
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// isPublicNode checks if a node is public, by simply checking if there's any
|
|
|
|
|
@ -106,30 +111,33 @@ func parseOutPoint(s string) (*wire.OutPoint, error) {
|
|
|
|
|
}, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// getAlias tries to get the ShortChannelId from the passed ChannelId and
|
|
|
|
|
// aliasCache.
|
|
|
|
|
func getAlias(aliasCache map[lnwire.ChannelID]lnwire.ShortChannelID,
|
|
|
|
|
channelID lnwire.ChannelID) (lnwire.ShortChannelID, error) {
|
|
|
|
|
|
|
|
|
|
if channelID, ok := aliasCache[channelID]; ok {
|
|
|
|
|
return channelID, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return lnwire.ShortChannelID{}, fmt.Errorf("can't find channelId")
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// SelectHopHints calls into LND's exposed SelectHopHints prefiltered to the
|
|
|
|
|
// includeNodes map (unless it's empty).
|
|
|
|
|
func SelectHopHints(ctx context.Context, lnd *lndclient.LndServices,
|
|
|
|
|
amt btcutil.Amount, numMaxHophints int,
|
|
|
|
|
includeNodes map[route.Vertex]struct{}) ([][]zpay32.HopHint, error) {
|
|
|
|
|
|
|
|
|
|
cfg := &invoicesrpc.SelectHopHintsCfg{
|
|
|
|
|
IsPublicNode: func(pubKey [33]byte) (bool, error) {
|
|
|
|
|
return isPublicNode(ctx, lnd, pubKey)
|
|
|
|
|
},
|
|
|
|
|
FetchChannelEdgesByID: func(chanID uint64) (
|
|
|
|
|
*channeldb.ChannelEdgeInfo, *channeldb.ChannelEdgePolicy,
|
|
|
|
|
*channeldb.ChannelEdgePolicy, error) {
|
|
|
|
|
aliasCache := make(map[lnwire.ChannelID]lnwire.ShortChannelID)
|
|
|
|
|
|
|
|
|
|
return fetchChannelEdgesByID(ctx, lnd, chanID)
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
// Fetch all active and public channels.
|
|
|
|
|
channels, err := lnd.Client.ListChannels(ctx, false, false)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
openChannels := []*invoicesrpc.HopHintInfo{}
|
|
|
|
|
openChannels := []*HopHintInfo{}
|
|
|
|
|
for _, channel := range channels {
|
|
|
|
|
if len(includeNodes) > 0 {
|
|
|
|
|
if _, ok := includeNodes[channel.PubKeyBytes]; !ok {
|
|
|
|
|
@ -148,7 +156,7 @@ func SelectHopHints(ctx context.Context, lnd *lndclient.LndServices,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
openChannels = append(
|
|
|
|
|
openChannels, &invoicesrpc.HopHintInfo{
|
|
|
|
|
openChannels, &HopHintInfo{
|
|
|
|
|
IsPublic: !channel.Private,
|
|
|
|
|
IsActive: channel.Active,
|
|
|
|
|
FundingOutpoint: *outPoint,
|
|
|
|
|
@ -159,11 +167,333 @@ func SelectHopHints(ctx context.Context, lnd *lndclient.LndServices,
|
|
|
|
|
ShortChannelID: channel.ChannelID,
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
channelID := lnwire.NewChanIDFromOutPoint(outPoint)
|
|
|
|
|
scID := lnwire.NewShortChanIDFromInt(channel.ChannelID)
|
|
|
|
|
aliasCache[channelID] = scID
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cfg := &SelectHopHintsCfg{
|
|
|
|
|
IsPublicNode: func(pubKey [33]byte) (bool, error) {
|
|
|
|
|
return isPublicNode(ctx, lnd, pubKey)
|
|
|
|
|
},
|
|
|
|
|
FetchChannelEdgesByID: func(chanID uint64) (
|
|
|
|
|
*channeldb.ChannelEdgeInfo, *channeldb.ChannelEdgePolicy,
|
|
|
|
|
*channeldb.ChannelEdgePolicy, error) {
|
|
|
|
|
|
|
|
|
|
return fetchChannelEdgesByID(ctx, lnd, chanID)
|
|
|
|
|
},
|
|
|
|
|
GetAlias: func(id lnwire.ChannelID) (
|
|
|
|
|
lnwire.ShortChannelID, error) {
|
|
|
|
|
|
|
|
|
|
return getAlias(aliasCache, id)
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
routeHints := invoicesrpc.SelectHopHints(
|
|
|
|
|
routeHints := invoicesrpcSelectHopHints(
|
|
|
|
|
lnwire.MilliSatoshi(amt*1000), cfg, openChannels, numMaxHophints,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
return routeHints, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// chanCanBeHopHint returns true if the target channel is eligible to be a hop
|
|
|
|
|
// hint.
|
|
|
|
|
func chanCanBeHopHint(channel *HopHintInfo, cfg *SelectHopHintsCfg) (
|
|
|
|
|
*channeldb.ChannelEdgePolicy, bool) {
|
|
|
|
|
|
|
|
|
|
// Since we're only interested in our private channels, we'll skip
|
|
|
|
|
// public ones.
|
|
|
|
|
if channel.IsPublic {
|
|
|
|
|
return nil, false
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Make sure the channel is active.
|
|
|
|
|
if !channel.IsActive {
|
|
|
|
|
log.Debugf("Skipping channel %v due to not "+
|
|
|
|
|
"being eligible to forward payments",
|
|
|
|
|
channel.ShortChannelID)
|
|
|
|
|
return nil, false
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// To ensure we don't leak unadvertised nodes, we'll make sure our
|
|
|
|
|
// counterparty is publicly advertised within the network. Otherwise,
|
|
|
|
|
// we'll end up leaking information about nodes that intend to stay
|
|
|
|
|
// unadvertised, like in the case of a node only having private
|
|
|
|
|
// channels.
|
|
|
|
|
var remotePub [33]byte
|
|
|
|
|
copy(remotePub[:], channel.RemotePubkey.SerializeCompressed())
|
|
|
|
|
isRemoteNodePublic, err := cfg.IsPublicNode(remotePub)
|
|
|
|
|
if err != nil {
|
|
|
|
|
log.Errorf("Unable to determine if node %x "+
|
|
|
|
|
"is advertised: %v", remotePub, err)
|
|
|
|
|
return nil, false
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if !isRemoteNodePublic {
|
|
|
|
|
log.Debugf("Skipping channel %v due to "+
|
|
|
|
|
"counterparty %x being unadvertised",
|
|
|
|
|
channel.ShortChannelID, remotePub)
|
|
|
|
|
return nil, false
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fetch the policies for each end of the channel.
|
|
|
|
|
info, p1, p2, err := cfg.FetchChannelEdgesByID(channel.ShortChannelID)
|
|
|
|
|
if err != nil {
|
|
|
|
|
// In the case of zero-conf channels, it may be the case that
|
|
|
|
|
// the alias SCID was deleted from the graph, and replaced by
|
|
|
|
|
// the confirmed SCID. Check the Graph for the confirmed SCID.
|
|
|
|
|
confirmedScid := channel.ConfirmedScidZC
|
|
|
|
|
info, p1, p2, err = cfg.FetchChannelEdgesByID(confirmedScid)
|
|
|
|
|
if err != nil {
|
|
|
|
|
log.Errorf("Unable to fetch the routing policies for "+
|
|
|
|
|
"the edges of the channel %v: %v",
|
|
|
|
|
channel.ShortChannelID, err)
|
|
|
|
|
return nil, false
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Now, we'll need to determine which is the correct policy for HTLCs
|
|
|
|
|
// being sent from the remote node.
|
|
|
|
|
var remotePolicy *channeldb.ChannelEdgePolicy
|
|
|
|
|
if bytes.Equal(remotePub[:], info.NodeKey1Bytes[:]) {
|
|
|
|
|
remotePolicy = p1
|
|
|
|
|
} else {
|
|
|
|
|
remotePolicy = p2
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return remotePolicy, true
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// addHopHint creates a hop hint out of the passed channel and channel policy.
|
|
|
|
|
// The new hop hint is appended to the passed slice.
|
|
|
|
|
func addHopHint(hopHints *[][]zpay32.HopHint,
|
|
|
|
|
channel *HopHintInfo, chanPolicy *channeldb.ChannelEdgePolicy,
|
|
|
|
|
aliasScid lnwire.ShortChannelID) {
|
|
|
|
|
|
|
|
|
|
hopHint := zpay32.HopHint{
|
|
|
|
|
NodeID: channel.RemotePubkey,
|
|
|
|
|
ChannelID: channel.ShortChannelID,
|
|
|
|
|
FeeBaseMSat: uint32(chanPolicy.FeeBaseMSat),
|
|
|
|
|
FeeProportionalMillionths: uint32(
|
|
|
|
|
chanPolicy.FeeProportionalMillionths,
|
|
|
|
|
),
|
|
|
|
|
CLTVExpiryDelta: chanPolicy.TimeLockDelta,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var defaultScid lnwire.ShortChannelID
|
|
|
|
|
if aliasScid != defaultScid {
|
|
|
|
|
hopHint.ChannelID = aliasScid.ToUint64()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*hopHints = append(*hopHints, []zpay32.HopHint{hopHint})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// HopHintInfo contains the channel information required to create a hop hint.
|
|
|
|
|
type HopHintInfo struct {
|
|
|
|
|
// IsPublic indicates whether a channel is advertised to the network.
|
|
|
|
|
IsPublic bool
|
|
|
|
|
|
|
|
|
|
// IsActive indicates whether the channel is online and available for
|
|
|
|
|
// use.
|
|
|
|
|
IsActive bool
|
|
|
|
|
|
|
|
|
|
// FundingOutpoint is the funding txid:index for the channel.
|
|
|
|
|
FundingOutpoint wire.OutPoint
|
|
|
|
|
|
|
|
|
|
// RemotePubkey is the public key of the remote party that this channel
|
|
|
|
|
// is in.
|
|
|
|
|
RemotePubkey *btcec.PublicKey
|
|
|
|
|
|
|
|
|
|
// RemoteBalance is the remote party's balance (our current incoming
|
|
|
|
|
// capacity).
|
|
|
|
|
RemoteBalance lnwire.MilliSatoshi
|
|
|
|
|
|
|
|
|
|
// ShortChannelID is the short channel ID of the channel.
|
|
|
|
|
ShortChannelID uint64
|
|
|
|
|
|
|
|
|
|
// ConfirmedScidZC is the confirmed SCID of a zero-conf channel. This
|
|
|
|
|
// may be used for looking up a channel in the graph.
|
|
|
|
|
ConfirmedScidZC uint64
|
|
|
|
|
|
|
|
|
|
// ScidAliasFeature denotes whether the channel has negotiated the
|
|
|
|
|
// option-scid-alias feature bit.
|
|
|
|
|
ScidAliasFeature bool
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// SelectHopHintsCfg contains the dependencies required to obtain hop hints
|
|
|
|
|
// for an invoice.
|
|
|
|
|
type SelectHopHintsCfg struct {
|
|
|
|
|
// IsPublicNode is returns a bool indicating whether the node with the
|
|
|
|
|
// given public key is seen as a public node in the graph from the
|
|
|
|
|
// graph's source node's point of view.
|
|
|
|
|
IsPublicNode func(pubKey [33]byte) (bool, error)
|
|
|
|
|
|
|
|
|
|
// FetchChannelEdgesByID attempts to lookup the two directed edges for
|
|
|
|
|
// the channel identified by the channel ID.
|
|
|
|
|
FetchChannelEdgesByID func(chanID uint64) (*channeldb.ChannelEdgeInfo,
|
|
|
|
|
*channeldb.ChannelEdgePolicy, *channeldb.ChannelEdgePolicy,
|
|
|
|
|
error)
|
|
|
|
|
|
|
|
|
|
// GetAlias allows the peer's alias SCID to be retrieved for private
|
|
|
|
|
// option_scid_alias channels.
|
|
|
|
|
GetAlias func(lnwire.ChannelID) (lnwire.ShortChannelID, error)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// sufficientHints checks whether we have sufficient hop hints, based on the
|
|
|
|
|
// following criteria:
|
|
|
|
|
// - Hop hint count: limit to a set number of hop hints, regardless of whether
|
|
|
|
|
// we've reached our invoice amount or not.
|
|
|
|
|
// - Total incoming capacity: limit to our invoice amount * scaling factor to
|
|
|
|
|
// allow for some of our links going offline.
|
|
|
|
|
//
|
|
|
|
|
// We limit our number of hop hints like this to keep our invoice size down,
|
|
|
|
|
// and to avoid leaking all our private channels when we don't need to.
|
|
|
|
|
func sufficientHints(numHints, maxHints, scalingFactor int, amount,
|
|
|
|
|
totalHintAmount lnwire.MilliSatoshi) bool {
|
|
|
|
|
|
|
|
|
|
if numHints >= maxHints {
|
|
|
|
|
log.Debug("Reached maximum number of hop hints")
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
requiredAmount := amount * lnwire.MilliSatoshi(scalingFactor)
|
|
|
|
|
if totalHintAmount >= requiredAmount {
|
|
|
|
|
log.Debugf("Total hint amount: %v has reached target hint "+
|
|
|
|
|
"bandwidth: %v (invoice amount: %v * factor: %v)",
|
|
|
|
|
totalHintAmount, requiredAmount, amount,
|
|
|
|
|
scalingFactor)
|
|
|
|
|
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// SelectHopHints will select up to numMaxHophints from the set of passed open
|
|
|
|
|
// channels. The set of hop hints will be returned as a slice of functional
|
|
|
|
|
// options that'll append the route hint to the set of all route hints.
|
|
|
|
|
//
|
|
|
|
|
// TODO(sputn1ck): remove when https://github.com/lightningnetwork/lnd/pull/7065
|
|
|
|
|
// is merged to a new lnd release.
|
|
|
|
|
func invoicesrpcSelectHopHints(amtMSat lnwire.MilliSatoshi, cfg *SelectHopHintsCfg,
|
|
|
|
|
openChannels []*HopHintInfo,
|
|
|
|
|
numMaxHophints int) [][]zpay32.HopHint {
|
|
|
|
|
|
|
|
|
|
// We'll add our hop hints in two passes, first we'll add all channels
|
|
|
|
|
// that are eligible to be hop hints, and also have a local balance
|
|
|
|
|
// above the payment amount.
|
|
|
|
|
var totalHintBandwidth lnwire.MilliSatoshi
|
|
|
|
|
hopHintChans := make(map[wire.OutPoint]struct{})
|
|
|
|
|
hopHints := make([][]zpay32.HopHint, 0, numMaxHophints)
|
|
|
|
|
for _, channel := range openChannels {
|
|
|
|
|
enoughHopHints := sufficientHints(
|
|
|
|
|
len(hopHints), numMaxHophints, hopHintFactor, amtMSat,
|
|
|
|
|
totalHintBandwidth,
|
|
|
|
|
)
|
|
|
|
|
if enoughHopHints {
|
|
|
|
|
log.Debugf("First pass of hop selection has " +
|
|
|
|
|
"sufficient hints")
|
|
|
|
|
|
|
|
|
|
return hopHints
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If this channel can't be a hop hint, then skip it.
|
|
|
|
|
edgePolicy, canBeHopHint := chanCanBeHopHint(channel, cfg)
|
|
|
|
|
if edgePolicy == nil || !canBeHopHint {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Similarly, in this first pass, we'll ignore all channels in
|
|
|
|
|
// isolation can't satisfy this payment.
|
|
|
|
|
if channel.RemoteBalance < amtMSat {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Lookup and see if there is an alias SCID that exists.
|
|
|
|
|
chanID := lnwire.NewChanIDFromOutPoint(
|
|
|
|
|
&channel.FundingOutpoint,
|
|
|
|
|
)
|
|
|
|
|
alias, _ := cfg.GetAlias(chanID)
|
|
|
|
|
|
|
|
|
|
// If this is a channel where the option-scid-alias feature bit
|
|
|
|
|
// was negotiated and the alias is not yet assigned, we cannot
|
|
|
|
|
// issue an invoice. Doing so might expose the confirmed SCID
|
|
|
|
|
// of a private channel.
|
|
|
|
|
if channel.ScidAliasFeature {
|
|
|
|
|
var defaultScid lnwire.ShortChannelID
|
|
|
|
|
if alias == defaultScid {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Now that we now this channel use usable, add it as a hop
|
|
|
|
|
// hint and the indexes we'll use later.
|
|
|
|
|
addHopHint(&hopHints, channel, edgePolicy, alias)
|
|
|
|
|
|
|
|
|
|
hopHintChans[channel.FundingOutpoint] = struct{}{}
|
|
|
|
|
totalHintBandwidth += channel.RemoteBalance
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// In this second pass we'll add channels, and we'll either stop when
|
|
|
|
|
// we have 20 hop hints, we've run through all the available channels,
|
|
|
|
|
// or if the sum of available bandwidth in the routing hints exceeds 2x
|
|
|
|
|
// the payment amount. We do 2x here to account for a margin of error
|
|
|
|
|
// if some of the selected channels no longer become operable.
|
|
|
|
|
for i := 0; i < len(openChannels); i++ {
|
|
|
|
|
enoughHopHints := sufficientHints(
|
|
|
|
|
len(hopHints), numMaxHophints, hopHintFactor, amtMSat,
|
|
|
|
|
totalHintBandwidth,
|
|
|
|
|
)
|
|
|
|
|
if enoughHopHints {
|
|
|
|
|
log.Debugf("Second pass of hop selection has " +
|
|
|
|
|
"sufficient hints")
|
|
|
|
|
|
|
|
|
|
return hopHints
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
channel := openChannels[i]
|
|
|
|
|
|
|
|
|
|
// Skip the channel if we already selected it.
|
|
|
|
|
if _, ok := hopHintChans[channel.FundingOutpoint]; ok {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If the channel can't be a hop hint, then we'll skip it.
|
|
|
|
|
// Otherwise, we'll use the policy information to populate the
|
|
|
|
|
// hop hint.
|
|
|
|
|
remotePolicy, canBeHopHint := chanCanBeHopHint(channel, cfg)
|
|
|
|
|
if !canBeHopHint || remotePolicy == nil {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Lookup and see if there's an alias SCID that exists.
|
|
|
|
|
chanID := lnwire.NewChanIDFromOutPoint(
|
|
|
|
|
&channel.FundingOutpoint,
|
|
|
|
|
)
|
|
|
|
|
alias, _ := cfg.GetAlias(chanID)
|
|
|
|
|
|
|
|
|
|
// If this is a channel where the option-scid-alias feature bit
|
|
|
|
|
// was negotiated and the alias is not yet assigned, we cannot
|
|
|
|
|
// issue an invoice. Doing so might expose the confirmed SCID
|
|
|
|
|
// of a private channel.
|
|
|
|
|
if channel.ScidAliasFeature {
|
|
|
|
|
var defaultScid lnwire.ShortChannelID
|
|
|
|
|
if alias == defaultScid {
|
|
|
|
|
continue
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Include the route hint in our set of options that will be
|
|
|
|
|
// used when creating the invoice.
|
|
|
|
|
addHopHint(&hopHints, channel, remotePolicy, alias)
|
|
|
|
|
|
|
|
|
|
// As we've just added a new hop hint, we'll accumulate it's
|
|
|
|
|
// available balance now to update our tally.
|
|
|
|
|
//
|
|
|
|
|
// TODO(roasbeef): have a cut off based on min bandwidth?
|
|
|
|
|
totalHintBandwidth += channel.RemoteBalance
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return hopHints
|
|
|
|
|
}
|
|
|
|
|
|
sputn1ck
2 years ago