130 lines
4.0 KiB
Go
130 lines
4.0 KiB
Go
package routing
|
|
|
|
import (
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
)
|
|
|
|
// nodeWithDist is a helper struct that couples the distance from the current
|
|
// source to a node with a pointer to the node itself.
|
|
type nodeWithDist struct {
|
|
// dist is the distance to this node from the source node in our
|
|
// current context.
|
|
dist int64
|
|
|
|
// node is the vertex itself. This pointer can be used to explore all
|
|
// the outgoing edges (channels) emanating from a node.
|
|
node *channeldb.LightningNode
|
|
|
|
// amountToReceive is the amount that should be received by this node.
|
|
// Either as final payment to the final node or as an intermediate
|
|
// amount that includes also the fees for subsequent hops.
|
|
amountToReceive lnwire.MilliSatoshi
|
|
|
|
// fee is the fee that this node is charging for forwarding.
|
|
fee lnwire.MilliSatoshi
|
|
}
|
|
|
|
// distanceHeap is a min-distance heap that's used within our path finding
|
|
// algorithm to keep track of the "closest" node to our source node.
|
|
type distanceHeap struct {
|
|
nodes []nodeWithDist
|
|
}
|
|
|
|
// Len returns the number of nodes in the priority queue.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (d *distanceHeap) Len() int { return len(d.nodes) }
|
|
|
|
// Less returns whether the item in the priority queue with index i should sort
|
|
// before the item with index j.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (d *distanceHeap) Less(i, j int) bool {
|
|
return d.nodes[i].dist < d.nodes[j].dist
|
|
}
|
|
|
|
// Swap swaps the nodes at the passed indices in the priority queue.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (d *distanceHeap) Swap(i, j int) {
|
|
d.nodes[i], d.nodes[j] = d.nodes[j], d.nodes[i]
|
|
}
|
|
|
|
// Push pushes the passed item onto the priority queue.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (d *distanceHeap) Push(x interface{}) {
|
|
d.nodes = append(d.nodes, x.(nodeWithDist))
|
|
}
|
|
|
|
// Pop removes the highest priority item (according to Less) from the priority
|
|
// queue and returns it.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (d *distanceHeap) Pop() interface{} {
|
|
n := len(d.nodes)
|
|
x := d.nodes[n-1]
|
|
d.nodes = d.nodes[0 : n-1]
|
|
return x
|
|
}
|
|
|
|
// path represents an ordered set of edges which forms an available path from a
|
|
// given source node to our destination. During the process of computing the
|
|
// KSP's from a source to destination, several path swill be considered in the
|
|
// process.
|
|
type path struct {
|
|
// dist is the distance from the source node to the destination node
|
|
// that the path requires.
|
|
dist int
|
|
|
|
// hops is an ordered list of edge that comprises a potential payment
|
|
// path.
|
|
hops []*ChannelHop
|
|
}
|
|
|
|
// pathHeap is a min-heap that stores potential paths to be considered within
|
|
// our KSP implementation. The heap sorts paths according to their cumulative
|
|
// distance from a given source.
|
|
type pathHeap struct {
|
|
paths []path
|
|
}
|
|
|
|
// Len returns the number of nodes in the priority queue.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (p *pathHeap) Len() int { return len(p.paths) }
|
|
|
|
// Less returns whether the item in the priority queue with index i should sort
|
|
// before the item with index j.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (p *pathHeap) Less(i, j int) bool {
|
|
return p.paths[i].dist < p.paths[j].dist
|
|
}
|
|
|
|
// Swap swaps the nodes at the passed indices in the priority queue.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (p *pathHeap) Swap(i, j int) {
|
|
p.paths[i], p.paths[j] = p.paths[j], p.paths[i]
|
|
}
|
|
|
|
// Push pushes the passed item onto the priority queue.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (p *pathHeap) Push(x interface{}) {
|
|
p.paths = append(p.paths, x.(path))
|
|
}
|
|
|
|
// Pop removes the highest priority item (according to Less) from the priority
|
|
// queue and returns it.
|
|
//
|
|
// NOTE: This is part of the heap.Interface implementation.
|
|
func (p *pathHeap) Pop() interface{} {
|
|
n := len(p.paths)
|
|
x := p.paths[n-1]
|
|
p.paths = p.paths[0 : n-1]
|
|
return x
|
|
}
|