650 lines
17 KiB
Go
650 lines
17 KiB
Go
package autopilot
|
|
|
|
import (
|
|
"io/ioutil"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
prand "math/rand"
|
|
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
func TestConstrainedPrefAttachmentNeedMoreChan(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
prand.Seed(time.Now().Unix())
|
|
|
|
const (
|
|
minChanSize = 0
|
|
maxChanSize = btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
|
|
chanLimit = 3
|
|
|
|
threshold = 0.5
|
|
)
|
|
|
|
randChanID := func() lnwire.ShortChannelID {
|
|
return lnwire.NewShortChanIDFromInt(uint64(prand.Int63()))
|
|
}
|
|
|
|
testCases := []struct {
|
|
channels []Channel
|
|
walletAmt btcutil.Amount
|
|
|
|
needMore bool
|
|
amtAvailable btcutil.Amount
|
|
numMore uint32
|
|
}{
|
|
// Many available funds, but already have too many active open
|
|
// channels.
|
|
{
|
|
[]Channel{
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(prand.Int31()),
|
|
},
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(prand.Int31()),
|
|
},
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(prand.Int31()),
|
|
},
|
|
},
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin * 10),
|
|
false,
|
|
0,
|
|
0,
|
|
},
|
|
|
|
// Ratio of funds in channels and total funds meets the
|
|
// threshold.
|
|
{
|
|
[]Channel{
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
},
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
},
|
|
},
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin * 2),
|
|
false,
|
|
0,
|
|
0,
|
|
},
|
|
|
|
// Ratio of funds in channels and total funds is below the
|
|
// threshold. We have 10 BTC allocated amongst channels and
|
|
// funds, atm. We're targeting 50%, so 5 BTC should be
|
|
// allocated. Only 1 BTC is atm, so 4 BTC should be
|
|
// recommended. We should also request 2 more channels as the
|
|
// limit is 3.
|
|
{
|
|
[]Channel{
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
},
|
|
},
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin * 9),
|
|
true,
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin * 4),
|
|
2,
|
|
},
|
|
|
|
// Ratio of funds in channels and total funds is below the
|
|
// threshold. We have 14 BTC total amongst the wallet's
|
|
// balance, and our currently opened channels. Since we're
|
|
// targeting a 50% allocation, we should commit 7 BTC. The
|
|
// current channels commit 4 BTC, so we should expected 3 BTC
|
|
// to be committed. We should only request a single additional
|
|
// channel as the limit is 3.
|
|
{
|
|
[]Channel{
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
},
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin * 3),
|
|
},
|
|
},
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin * 10),
|
|
true,
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin * 3),
|
|
1,
|
|
},
|
|
|
|
// Ratio of funds in channels and total funds is above the
|
|
// threshold.
|
|
{
|
|
[]Channel{
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
},
|
|
{
|
|
ChanID: randChanID(),
|
|
Capacity: btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
},
|
|
},
|
|
btcutil.Amount(btcutil.SatoshiPerBitcoin),
|
|
false,
|
|
0,
|
|
0,
|
|
},
|
|
}
|
|
|
|
prefAttach := NewConstrainedPrefAttachment(minChanSize, maxChanSize,
|
|
chanLimit, threshold)
|
|
|
|
for i, testCase := range testCases {
|
|
amtToAllocate, numMore, needMore := prefAttach.NeedMoreChans(
|
|
testCase.channels, testCase.walletAmt,
|
|
)
|
|
|
|
if amtToAllocate != testCase.amtAvailable {
|
|
t.Fatalf("test #%v: expected %v, got %v",
|
|
i, testCase.amtAvailable, amtToAllocate)
|
|
}
|
|
if needMore != testCase.needMore {
|
|
t.Fatalf("test #%v: expected %v, got %v",
|
|
i, testCase.needMore, needMore)
|
|
}
|
|
if numMore != testCase.numMore {
|
|
t.Fatalf("test #%v: expected %v, got %v",
|
|
i, testCase.numMore, numMore)
|
|
}
|
|
}
|
|
}
|
|
|
|
type genGraphFunc func() (testGraph, func(), error)
|
|
|
|
type testGraph interface {
|
|
ChannelGraph
|
|
|
|
addRandChannel(*btcec.PublicKey, *btcec.PublicKey,
|
|
btcutil.Amount) (*ChannelEdge, *ChannelEdge, error)
|
|
}
|
|
|
|
func newDiskChanGraph() (testGraph, func(), error) {
|
|
// First, create a temporary directory to be used for the duration of
|
|
// this test.
|
|
tempDirName, err := ioutil.TempDir("", "channeldb")
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Next, create channeldb for the first time.
|
|
cdb, err := channeldb.Open(tempDirName)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
cleanUp := func() {
|
|
cdb.Close()
|
|
os.RemoveAll(tempDirName)
|
|
}
|
|
|
|
return &databaseChannelGraph{
|
|
db: cdb.ChannelGraph(),
|
|
}, cleanUp, nil
|
|
}
|
|
|
|
var _ testGraph = (*databaseChannelGraph)(nil)
|
|
|
|
func newMemChanGraph() (testGraph, func(), error) {
|
|
return newMemChannelGraph(), nil, nil
|
|
}
|
|
|
|
var _ testGraph = (*memChannelGraph)(nil)
|
|
|
|
var chanGraphs = []struct {
|
|
name string
|
|
genFunc genGraphFunc
|
|
}{
|
|
{
|
|
name: "disk_graph",
|
|
genFunc: newDiskChanGraph,
|
|
},
|
|
{
|
|
name: "mem_graph",
|
|
genFunc: newMemChanGraph,
|
|
},
|
|
}
|
|
|
|
// TestConstrainedPrefAttachmentSelectEmptyGraph ensures that when passed en
|
|
// empty graph, the Select function always detects the state, and returns nil.
|
|
// Otherwise, it would be possible for the main Select loop to entire an
|
|
// infinite loop.
|
|
func TestConstrainedPrefAttachmentSelectEmptyGraph(t *testing.T) {
|
|
const (
|
|
minChanSize = 0
|
|
maxChanSize = btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
chanLimit = 3
|
|
threshold = 0.5
|
|
)
|
|
|
|
// First, we'll generate a random key that represents "us", and create
|
|
// a new instance of the heuristic with our set parameters.
|
|
self, err := randKey()
|
|
if err != nil {
|
|
t.Fatalf("unable to generate self key: %v", err)
|
|
}
|
|
prefAttach := NewConstrainedPrefAttachment(minChanSize, maxChanSize,
|
|
chanLimit, threshold)
|
|
|
|
skipNodes := make(map[NodeID]struct{})
|
|
for _, graph := range chanGraphs {
|
|
success := t.Run(graph.name, func(t1 *testing.T) {
|
|
graph, cleanup, err := graph.genFunc()
|
|
if err != nil {
|
|
t1.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
|
|
// With the necessary state initialized, we'll not
|
|
// attempt to select a set of candidates channel for
|
|
// creation given the current state of the graph.
|
|
const walletFunds = btcutil.SatoshiPerBitcoin
|
|
directives, err := prefAttach.Select(self, graph,
|
|
walletFunds, 5, skipNodes)
|
|
if err != nil {
|
|
t1.Fatalf("unable to select attachment "+
|
|
"directives: %v", err)
|
|
}
|
|
|
|
// We shouldn't have selected any new directives as we
|
|
// started with an empty graph.
|
|
if len(directives) != 0 {
|
|
t1.Fatalf("zero attachment directives "+
|
|
"should have been returned instead %v were",
|
|
len(directives))
|
|
}
|
|
})
|
|
if !success {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestConstrainedPrefAttachmentSelectTwoVertexes ensures that when passed a
|
|
// graph with only two eligible vertexes, then both are selected (without any
|
|
// repeats), and the funds are appropriately allocated across each peer.
|
|
func TestConstrainedPrefAttachmentSelectTwoVertexes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
prand.Seed(time.Now().Unix())
|
|
|
|
const (
|
|
minChanSize = 0
|
|
maxChanSize = btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
chanLimit = 3
|
|
threshold = 0.5
|
|
)
|
|
|
|
skipNodes := make(map[NodeID]struct{})
|
|
for _, graph := range chanGraphs {
|
|
success := t.Run(graph.name, func(t1 *testing.T) {
|
|
graph, cleanup, err := graph.genFunc()
|
|
if err != nil {
|
|
t1.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
|
|
// First, we'll generate a random key that represents
|
|
// "us", and create a new instance of the heuristic
|
|
// with our set parameters.
|
|
self, err := randKey()
|
|
if err != nil {
|
|
t1.Fatalf("unable to generate self key: %v", err)
|
|
}
|
|
prefAttach := NewConstrainedPrefAttachment(minChanSize, maxChanSize,
|
|
chanLimit, threshold)
|
|
|
|
// For this set, we'll load the memory graph with two
|
|
// nodes, and a random channel connecting them.
|
|
const chanCapacity = btcutil.SatoshiPerBitcoin
|
|
edge1, edge2, err := graph.addRandChannel(nil, nil, chanCapacity)
|
|
if err != nil {
|
|
t1.Fatalf("unable to generate channel: %v", err)
|
|
}
|
|
|
|
// With the necessary state initialized, we'll not
|
|
// attempt to select a set of candidates channel for
|
|
// creation given the current state of the graph.
|
|
const walletFunds = btcutil.SatoshiPerBitcoin * 10
|
|
directives, err := prefAttach.Select(self, graph,
|
|
walletFunds, 2, skipNodes)
|
|
if err != nil {
|
|
t1.Fatalf("unable to select attachment directives: %v", err)
|
|
}
|
|
|
|
// Two new directives should have been selected, one
|
|
// for each node already present within the graph.
|
|
if len(directives) != 2 {
|
|
t1.Fatalf("two attachment directives should have been "+
|
|
"returned instead %v were", len(directives))
|
|
}
|
|
|
|
// The node attached to should be amongst the two edges
|
|
// created above.
|
|
for _, directive := range directives {
|
|
switch {
|
|
case directive.PeerKey.IsEqual(edge1.Peer.PubKey()):
|
|
case directive.PeerKey.IsEqual(edge2.Peer.PubKey()):
|
|
default:
|
|
t1.Fatalf("attache to unknown node: %x",
|
|
directive.PeerKey.SerializeCompressed())
|
|
}
|
|
|
|
// As the number of funds available exceed the
|
|
// max channel size, both edges should consume
|
|
// the maximum channel size.
|
|
if directive.ChanAmt != maxChanSize {
|
|
t1.Fatalf("max channel size should be allocated, "+
|
|
"instead %v was: ", maxChanSize)
|
|
}
|
|
}
|
|
})
|
|
if !success {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestConstrainedPrefAttachmentSelectInsufficientFunds ensures that if the
|
|
// balance of the backing wallet is below the set min channel size, then it
|
|
// never recommends candidates to attach to.
|
|
func TestConstrainedPrefAttachmentSelectInsufficientFunds(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
prand.Seed(time.Now().Unix())
|
|
|
|
const (
|
|
minChanSize = 0
|
|
maxChanSize = btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
chanLimit = 3
|
|
threshold = 0.5
|
|
)
|
|
|
|
skipNodes := make(map[NodeID]struct{})
|
|
for _, graph := range chanGraphs {
|
|
success := t.Run(graph.name, func(t1 *testing.T) {
|
|
graph, cleanup, err := graph.genFunc()
|
|
if err != nil {
|
|
t1.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
|
|
// First, we'll generate a random key that represents
|
|
// "us", and create a new instance of the heuristic
|
|
// with our set parameters.
|
|
self, err := randKey()
|
|
if err != nil {
|
|
t1.Fatalf("unable to generate self key: %v", err)
|
|
}
|
|
prefAttach := NewConstrainedPrefAttachment(
|
|
minChanSize, maxChanSize, chanLimit, threshold,
|
|
)
|
|
|
|
// Next, we'll attempt to select a set of candidates,
|
|
// passing zero for the amount of wallet funds. This
|
|
// should return an empty slice of directives.
|
|
directives, err := prefAttach.Select(self, graph, 0,
|
|
0, skipNodes)
|
|
if err != nil {
|
|
t1.Fatalf("unable to select attachment "+
|
|
"directives: %v", err)
|
|
}
|
|
if len(directives) != 0 {
|
|
t1.Fatalf("zero attachment directives "+
|
|
"should have been returned instead %v were",
|
|
len(directives))
|
|
}
|
|
})
|
|
if !success {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestConstrainedPrefAttachmentSelectGreedyAllocation tests that if upon
|
|
// deciding a set of candidates, we're unable to evenly split our funds, then
|
|
// we attempt to greedily allocate all funds to each selected vertex (up to the
|
|
// max channel size).
|
|
func TestConstrainedPrefAttachmentSelectGreedyAllocation(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
prand.Seed(time.Now().Unix())
|
|
|
|
const (
|
|
minChanSize = 0
|
|
maxChanSize = btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
chanLimit = 3
|
|
threshold = 0.5
|
|
)
|
|
|
|
skipNodes := make(map[NodeID]struct{})
|
|
for _, graph := range chanGraphs {
|
|
success := t.Run(graph.name, func(t1 *testing.T) {
|
|
graph, cleanup, err := graph.genFunc()
|
|
if err != nil {
|
|
t1.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
|
|
// First, we'll generate a random key that represents
|
|
// "us", and create a new instance of the heuristic
|
|
// with our set parameters.
|
|
self, err := randKey()
|
|
if err != nil {
|
|
t1.Fatalf("unable to generate self key: %v", err)
|
|
}
|
|
prefAttach := NewConstrainedPrefAttachment(
|
|
minChanSize, maxChanSize, chanLimit, threshold,
|
|
)
|
|
|
|
const chanCapacity = btcutil.SatoshiPerBitcoin
|
|
|
|
// Next, we'll add 3 nodes to the graph, creating an
|
|
// "open triangle topology".
|
|
edge1, _, err := graph.addRandChannel(nil, nil,
|
|
chanCapacity)
|
|
if err != nil {
|
|
t1.Fatalf("unable to create channel: %v", err)
|
|
}
|
|
_, _, err = graph.addRandChannel(
|
|
edge1.Peer.PubKey(), nil, chanCapacity,
|
|
)
|
|
if err != nil {
|
|
t1.Fatalf("unable to create channel: %v", err)
|
|
}
|
|
|
|
// At this point, there should be three nodes in the
|
|
// graph, with node node having two edges.
|
|
numNodes := 0
|
|
twoChans := false
|
|
if err := graph.ForEachNode(func(n Node) error {
|
|
numNodes++
|
|
|
|
numChans := 0
|
|
err := n.ForEachChannel(func(c ChannelEdge) error {
|
|
numChans++
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
twoChans = twoChans || (numChans == 2)
|
|
|
|
return nil
|
|
}); err != nil {
|
|
t1.Fatalf("unable to traverse graph: %v", err)
|
|
}
|
|
if numNodes != 3 {
|
|
t1.Fatalf("expected 3 nodes, instead have: %v",
|
|
numNodes)
|
|
}
|
|
if !twoChans {
|
|
t1.Fatalf("expected node to have two channels")
|
|
}
|
|
|
|
// We'll now begin our test, modeling the available
|
|
// wallet balance to be 5.5 BTC. We're shooting for a
|
|
// 50/50 allocation, and have 3 BTC in channels. As a
|
|
// result, the heuristic should try to greedily
|
|
// allocate funds to channels.
|
|
const availableBalance = btcutil.SatoshiPerBitcoin * 2.5
|
|
directives, err := prefAttach.Select(self, graph,
|
|
availableBalance, 5, skipNodes)
|
|
if err != nil {
|
|
t1.Fatalf("unable to select attachment "+
|
|
"directives: %v", err)
|
|
}
|
|
|
|
// Three directives should have been returned.
|
|
if len(directives) != 3 {
|
|
t1.Fatalf("expected 3 directives, instead "+
|
|
"got: %v", len(directives))
|
|
}
|
|
|
|
// The two directive should have the max channel amount
|
|
// allocated.
|
|
if directives[0].ChanAmt != maxChanSize {
|
|
t1.Fatalf("expected recommendation of %v, "+
|
|
"instead got %v", maxChanSize,
|
|
directives[0].ChanAmt)
|
|
}
|
|
if directives[1].ChanAmt != maxChanSize {
|
|
t1.Fatalf("expected recommendation of %v, "+
|
|
"instead got %v", maxChanSize,
|
|
directives[1].ChanAmt)
|
|
}
|
|
|
|
// The third channel should have been allocated the
|
|
// remainder, or 0.5 BTC.
|
|
if directives[2].ChanAmt != (btcutil.SatoshiPerBitcoin * 0.5) {
|
|
t1.Fatalf("expected recommendation of %v, "+
|
|
"instead got %v", maxChanSize,
|
|
directives[2].ChanAmt)
|
|
}
|
|
})
|
|
if !success {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestConstrainedPrefAttachmentSelectSkipNodes ensures that if a node was
|
|
// already select for attachment, then that node is excluded from the set of
|
|
// candidate nodes.
|
|
func TestConstrainedPrefAttachmentSelectSkipNodes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
prand.Seed(time.Now().Unix())
|
|
|
|
const (
|
|
minChanSize = 0
|
|
maxChanSize = btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
chanLimit = 3
|
|
threshold = 0.5
|
|
)
|
|
|
|
for _, graph := range chanGraphs {
|
|
success := t.Run(graph.name, func(t1 *testing.T) {
|
|
skipNodes := make(map[NodeID]struct{})
|
|
|
|
graph, cleanup, err := graph.genFunc()
|
|
if err != nil {
|
|
t1.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
if cleanup != nil {
|
|
defer cleanup()
|
|
}
|
|
|
|
// First, we'll generate a random key that represents
|
|
// "us", and create a new instance of the heuristic
|
|
// with our set parameters.
|
|
self, err := randKey()
|
|
if err != nil {
|
|
t1.Fatalf("unable to generate self key: %v", err)
|
|
}
|
|
prefAttach := NewConstrainedPrefAttachment(
|
|
minChanSize, maxChanSize, chanLimit, threshold,
|
|
)
|
|
|
|
// Next, we'll create a simple topology of two nodes,
|
|
// with a single channel connecting them.
|
|
const chanCapacity = btcutil.SatoshiPerBitcoin
|
|
_, _, err = graph.addRandChannel(nil, nil,
|
|
chanCapacity)
|
|
if err != nil {
|
|
t1.Fatalf("unable to create channel: %v", err)
|
|
}
|
|
|
|
// With our graph created, we'll now execute the Select
|
|
// function to recommend potential attachment
|
|
// candidates.
|
|
const availableBalance = btcutil.SatoshiPerBitcoin * 2.5
|
|
directives, err := prefAttach.Select(self, graph,
|
|
availableBalance, 2, skipNodes)
|
|
if err != nil {
|
|
t1.Fatalf("unable to select attachment "+
|
|
"directives: %v", err)
|
|
}
|
|
|
|
// As the channel limit is three, and two nodes are
|
|
// present in the graph, both should be selected.
|
|
if len(directives) != 2 {
|
|
t1.Fatalf("expected two directives, instead "+
|
|
"got %v", len(directives))
|
|
}
|
|
|
|
// We'll simulate a channel update by adding the nodes
|
|
// we just establish channel with the to set of nodes
|
|
// to be skipped.
|
|
skipNodes[NewNodeID(directives[0].PeerKey)] = struct{}{}
|
|
skipNodes[NewNodeID(directives[1].PeerKey)] = struct{}{}
|
|
|
|
// If we attempt to make a call to the Select function,
|
|
// without providing any new information, then we
|
|
// should get no new directives as both nodes has
|
|
// already been attached to.
|
|
directives, err = prefAttach.Select(self, graph,
|
|
availableBalance, 2, skipNodes)
|
|
if err != nil {
|
|
t1.Fatalf("unable to select attachment "+
|
|
"directives: %v", err)
|
|
}
|
|
|
|
if len(directives) != 0 {
|
|
t1.Fatalf("zero new directives should have been "+
|
|
"selected, but %v were", len(directives))
|
|
}
|
|
})
|
|
if !success {
|
|
break
|
|
}
|
|
}
|
|
}
|