416f368979
This comment extends the unit tests for NewRoute with checks on the total time lock for a route as well as the expected time lock values for every hop along the route.
1341 lines
40 KiB
Go
1341 lines
40 KiB
Go
package routing
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"io/ioutil"
|
|
"math"
|
|
"math/big"
|
|
"net"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
"github.com/roasbeef/btcd/btcec"
|
|
"github.com/roasbeef/btcd/chaincfg/chainhash"
|
|
"github.com/roasbeef/btcd/wire"
|
|
"github.com/roasbeef/btcutil"
|
|
|
|
prand "math/rand"
|
|
)
|
|
|
|
const (
|
|
// basicGraphFilePath is the file path for a basic graph used within
|
|
// the tests. The basic graph consists of 5 nodes with 5 channels
|
|
// connecting them.
|
|
basicGraphFilePath = "testdata/basic_graph.json"
|
|
|
|
// excessiveHopsGraphFilePath is a file path which stores the JSON dump
|
|
// of a graph which was previously triggering an erroneous excessive
|
|
// hops error. The error has since been fixed, but a test case
|
|
// exercising it is kept around to guard against regressions.
|
|
excessiveHopsGraphFilePath = "testdata/excessive_hops.json"
|
|
|
|
// specExampleFilePath is a file path which stores an example which
|
|
// implementations will use in order to ensure that they're calculating
|
|
// the payload for each hop in path properly.
|
|
specExampleFilePath = "testdata/spec_example.json"
|
|
|
|
// noFeeLimit is the maximum value of a payment through Lightning. We
|
|
// can use this value to signal there is no fee limit since payments
|
|
// should never be larger than this.
|
|
noFeeLimit = lnwire.MilliSatoshi(math.MaxUint32)
|
|
)
|
|
|
|
var (
|
|
randSource = prand.NewSource(time.Now().Unix())
|
|
randInts = prand.New(randSource)
|
|
testSig = &btcec.Signature{
|
|
R: new(big.Int),
|
|
S: new(big.Int),
|
|
}
|
|
_, _ = testSig.R.SetString("63724406601629180062774974542967536251589935445068131219452686511677818569431", 10)
|
|
_, _ = testSig.S.SetString("18801056069249825825291287104931333862866033135609736119018462340006816851118", 10)
|
|
|
|
testAuthProof = channeldb.ChannelAuthProof{
|
|
NodeSig1Bytes: testSig.Serialize(),
|
|
NodeSig2Bytes: testSig.Serialize(),
|
|
BitcoinSig1Bytes: testSig.Serialize(),
|
|
BitcoinSig2Bytes: testSig.Serialize(),
|
|
}
|
|
)
|
|
|
|
// testGraph is the struct which corresponds to the JSON format used to encode
|
|
// graphs within the files in the testdata directory.
|
|
//
|
|
// TODO(roasbeef): add test graph auto-generator
|
|
type testGraph struct {
|
|
Info []string `json:"info"`
|
|
Nodes []testNode `json:"nodes"`
|
|
Edges []testChan `json:"edges"`
|
|
}
|
|
|
|
// testNode represents a node within the test graph above. We skip certain
|
|
// information such as the node's IP address as that information isn't needed
|
|
// for our tests.
|
|
type testNode struct {
|
|
Source bool `json:"source"`
|
|
PubKey string `json:"pubkey"`
|
|
Alias string `json:"alias"`
|
|
}
|
|
|
|
// testChan represents the JSON version of a payment channel. This struct
|
|
// matches the Json that's encoded under the "edges" key within the test graph.
|
|
type testChan struct {
|
|
Node1 string `json:"node_1"`
|
|
Node2 string `json:"node_2"`
|
|
ChannelID uint64 `json:"channel_id"`
|
|
ChannelPoint string `json:"channel_point"`
|
|
Flags uint16 `json:"flags"`
|
|
Expiry uint16 `json:"expiry"`
|
|
MinHTLC int64 `json:"min_htlc"`
|
|
FeeBaseMsat int64 `json:"fee_base_msat"`
|
|
FeeRate int64 `json:"fee_rate"`
|
|
Capacity int64 `json:"capacity"`
|
|
}
|
|
|
|
// makeTestGraph creates a new instance of a channeldb.ChannelGraph for testing
|
|
// purposes. A callback which cleans up the created temporary directories is
|
|
// also returned and intended to be executed after the test completes.
|
|
func makeTestGraph() (*channeldb.ChannelGraph, 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 cdb.ChannelGraph(), cleanUp, nil
|
|
}
|
|
|
|
// aliasMap is a map from a node's alias to its public key. This type is
|
|
// provided in order to allow easily look up from the human memorable alias
|
|
// to an exact node's public key.
|
|
type aliasMap map[string]*btcec.PublicKey
|
|
|
|
// parseTestGraph returns a fully populated ChannelGraph given a path to a JSON
|
|
// file which encodes a test graph.
|
|
func parseTestGraph(path string) (*channeldb.ChannelGraph, func(), aliasMap, error) {
|
|
graphJSON, err := ioutil.ReadFile(path)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
// First unmarshal the JSON graph into an instance of the testGraph
|
|
// struct. Using the struct tags created above in the struct, the JSON
|
|
// will be properly parsed into the struct above.
|
|
var g testGraph
|
|
if err := json.Unmarshal(graphJSON, &g); err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
// We'll use this fake address for the IP address of all the nodes in
|
|
// our tests. This value isn't needed for path finding so it doesn't
|
|
// need to be unique.
|
|
var testAddrs []net.Addr
|
|
testAddr, err := net.ResolveTCPAddr("tcp", "192.0.0.1:8888")
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
testAddrs = append(testAddrs, testAddr)
|
|
|
|
// Next, create a temporary graph database for usage within the test.
|
|
graph, cleanUp, err := makeTestGraph()
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
aliasMap := make(map[string]*btcec.PublicKey)
|
|
var source *channeldb.LightningNode
|
|
|
|
// First we insert all the nodes within the graph as vertexes.
|
|
for _, node := range g.Nodes {
|
|
pubBytes, err := hex.DecodeString(node.PubKey)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
dbNode := &channeldb.LightningNode{
|
|
HaveNodeAnnouncement: true,
|
|
AuthSigBytes: testSig.Serialize(),
|
|
LastUpdate: time.Now(),
|
|
Addresses: testAddrs,
|
|
Alias: node.Alias,
|
|
Features: testFeatures,
|
|
}
|
|
copy(dbNode.PubKeyBytes[:], pubBytes)
|
|
|
|
// We require all aliases within the graph to be unique for our
|
|
// tests.
|
|
if _, ok := aliasMap[node.Alias]; ok {
|
|
return nil, nil, nil, errors.New("aliases for nodes " +
|
|
"must be unique!")
|
|
}
|
|
|
|
pub, err := btcec.ParsePubKey(pubBytes, btcec.S256())
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
// If the alias is unique, then add the node to the
|
|
// alias map for easy lookup.
|
|
aliasMap[node.Alias] = pub
|
|
|
|
// If the node is tagged as the source, then we create a
|
|
// pointer to is so we can mark the source in the graph
|
|
// properly.
|
|
if node.Source {
|
|
// If we come across a node that's marked as the
|
|
// source, and we've already set the source in a prior
|
|
// iteration, then the JSON has an error as only ONE
|
|
// node can be the source in the graph.
|
|
if source != nil {
|
|
return nil, nil, nil, errors.New("JSON is invalid " +
|
|
"multiple nodes are tagged as the source")
|
|
}
|
|
|
|
source = dbNode
|
|
}
|
|
|
|
// With the node fully parsed, add it as a vertex within the
|
|
// graph.
|
|
if err := graph.AddLightningNode(dbNode); err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
}
|
|
|
|
if source != nil {
|
|
// Set the selected source node
|
|
if err := graph.SetSourceNode(source); err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
}
|
|
|
|
// With all the vertexes inserted, we can now insert the edges into the
|
|
// test graph.
|
|
for _, edge := range g.Edges {
|
|
node1Bytes, err := hex.DecodeString(edge.Node1)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
node2Bytes, err := hex.DecodeString(edge.Node2)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
fundingTXID := strings.Split(edge.ChannelPoint, ":")[0]
|
|
txidBytes, err := chainhash.NewHashFromStr(fundingTXID)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
fundingPoint := wire.OutPoint{
|
|
Hash: *txidBytes,
|
|
Index: 0,
|
|
}
|
|
|
|
// We first insert the existence of the edge between the two
|
|
// nodes.
|
|
edgeInfo := channeldb.ChannelEdgeInfo{
|
|
ChannelID: edge.ChannelID,
|
|
AuthProof: &testAuthProof,
|
|
ChannelPoint: fundingPoint,
|
|
Capacity: btcutil.Amount(edge.Capacity),
|
|
}
|
|
|
|
copy(edgeInfo.NodeKey1Bytes[:], node1Bytes)
|
|
copy(edgeInfo.NodeKey2Bytes[:], node2Bytes)
|
|
copy(edgeInfo.BitcoinKey1Bytes[:], node1Bytes)
|
|
copy(edgeInfo.BitcoinKey2Bytes[:], node2Bytes)
|
|
|
|
err = graph.AddChannelEdge(&edgeInfo)
|
|
if err != nil && err != channeldb.ErrEdgeAlreadyExist {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
edgePolicy := &channeldb.ChannelEdgePolicy{
|
|
SigBytes: testSig.Serialize(),
|
|
Flags: lnwire.ChanUpdateFlag(edge.Flags),
|
|
ChannelID: edge.ChannelID,
|
|
LastUpdate: time.Now(),
|
|
TimeLockDelta: edge.Expiry,
|
|
MinHTLC: lnwire.MilliSatoshi(edge.MinHTLC),
|
|
FeeBaseMSat: lnwire.MilliSatoshi(edge.FeeBaseMsat),
|
|
FeeProportionalMillionths: lnwire.MilliSatoshi(edge.FeeRate),
|
|
}
|
|
if err := graph.UpdateEdgePolicy(edgePolicy); err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
}
|
|
|
|
return graph, cleanUp, aliasMap, nil
|
|
}
|
|
|
|
func TestBasicGraphPathFinding(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
sourceVertex := Vertex(sourceNode.PubKeyBytes)
|
|
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
ignoredVertexes := make(map[Vertex]struct{})
|
|
|
|
// With the test graph loaded, we'll test some basic path finding using
|
|
// the pre-generated graph. Consult the testdata/basic_graph.json file
|
|
// to follow along with the assumptions we'll use to test the path
|
|
// finding.
|
|
const (
|
|
startingHeight = 100
|
|
finalHopCLTV = 1
|
|
)
|
|
|
|
paymentAmt := lnwire.NewMSatFromSatoshis(100)
|
|
target := aliases["sophon"]
|
|
path, err := findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, paymentAmt, nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to find path: %v", err)
|
|
}
|
|
|
|
route, err := newRoute(
|
|
paymentAmt, noFeeLimit, sourceVertex, path, startingHeight,
|
|
finalHopCLTV,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to create path: %v", err)
|
|
}
|
|
|
|
// The length of the route selected should be of exactly length two.
|
|
if len(route.Hops) != 2 {
|
|
t.Fatalf("route is of incorrect length, expected %v got %v", 2,
|
|
len(route.Hops))
|
|
}
|
|
|
|
// As each hop only decrements a single block from the time-lock, the
|
|
// total time lock value should two more than our starting block
|
|
// height.
|
|
if route.TotalTimeLock != 102 {
|
|
t.Fatalf("expected time lock of %v, instead have %v", 2,
|
|
route.TotalTimeLock)
|
|
}
|
|
|
|
// The first hop in the path should be an edge from roasbeef to goku.
|
|
if !bytes.Equal(route.Hops[0].Channel.Node.PubKeyBytes[:],
|
|
aliases["songoku"].SerializeCompressed()) {
|
|
|
|
t.Fatalf("first hop should be goku, is instead: %v",
|
|
route.Hops[0].Channel.Node.Alias)
|
|
}
|
|
|
|
// The second hop should be from goku to sophon.
|
|
if !bytes.Equal(route.Hops[1].Channel.Node.PubKeyBytes[:],
|
|
aliases["sophon"].SerializeCompressed()) {
|
|
|
|
t.Fatalf("second hop should be sophon, is instead: %v",
|
|
route.Hops[0].Channel.Node.Alias)
|
|
}
|
|
|
|
// Next, we'll assert that the "next hop" field in each route payload
|
|
// properly points to the channel ID that the HTLC should be forwarded
|
|
// along.
|
|
hopPayloads := route.ToHopPayloads()
|
|
if len(hopPayloads) != 2 {
|
|
t.Fatalf("incorrect number of hop payloads: expected %v, got %v",
|
|
2, len(hopPayloads))
|
|
}
|
|
|
|
// The first hop should point to the second hop.
|
|
var expectedHop [8]byte
|
|
binary.BigEndian.PutUint64(expectedHop[:], route.Hops[1].Channel.ChannelID)
|
|
if !bytes.Equal(hopPayloads[0].NextAddress[:], expectedHop[:]) {
|
|
t.Fatalf("first hop has incorrect next hop: expected %x, got %x",
|
|
expectedHop[:], hopPayloads[0].NextAddress)
|
|
}
|
|
|
|
// The second hop should have a next hop value of all zeroes in order
|
|
// to indicate it's the exit hop.
|
|
var exitHop [8]byte
|
|
if !bytes.Equal(hopPayloads[1].NextAddress[:], exitHop[:]) {
|
|
t.Fatalf("first hop has incorrect next hop: expected %x, got %x",
|
|
exitHop[:], hopPayloads[0].NextAddress)
|
|
}
|
|
|
|
// We'll also assert that the outgoing CLTV value for each hop was set
|
|
// accordingly.
|
|
if route.Hops[0].OutgoingTimeLock != 101 {
|
|
t.Fatalf("expected outgoing time-lock of %v, instead have %v",
|
|
1, route.Hops[0].OutgoingTimeLock)
|
|
}
|
|
if route.Hops[1].OutgoingTimeLock != 101 {
|
|
t.Fatalf("outgoing time-lock for final hop is incorrect: "+
|
|
"expected %v, got %v", 1, route.Hops[1].OutgoingTimeLock)
|
|
}
|
|
|
|
// Additionally, we'll ensure that the amount to forward, and fees
|
|
// computed for each hop are correct.
|
|
firstHopFee := computeFee(
|
|
paymentAmt, route.Hops[1].Channel.ChannelEdgePolicy,
|
|
)
|
|
if route.Hops[0].Fee != firstHopFee {
|
|
t.Fatalf("first hop fee incorrect: expected %v, got %v",
|
|
firstHopFee, route.Hops[0].Fee)
|
|
}
|
|
|
|
if route.TotalAmount != paymentAmt+firstHopFee {
|
|
t.Fatalf("first hop forwarding amount incorrect: expected %v, got %v",
|
|
paymentAmt+firstHopFee, route.TotalAmount)
|
|
}
|
|
if route.Hops[1].Fee != 0 {
|
|
t.Fatalf("first hop fee incorrect: expected %v, got %v",
|
|
firstHopFee, 0)
|
|
}
|
|
|
|
if route.Hops[1].AmtToForward != paymentAmt {
|
|
t.Fatalf("second hop forwarding amount incorrect: expected %v, got %v",
|
|
paymentAmt+firstHopFee, route.Hops[1].AmtToForward)
|
|
}
|
|
|
|
// Finally, the next and prev hop maps should be properly set.
|
|
//
|
|
// The previous hop from goku should be the channel from roasbeef, and
|
|
// the next hop should be the channel to sophon.
|
|
gokuPrevChan, ok := route.prevHopChannel(aliases["songoku"])
|
|
if !ok {
|
|
t.Fatalf("goku didn't have next chan but should have")
|
|
}
|
|
if gokuPrevChan.ChannelID != route.Hops[0].Channel.ChannelID {
|
|
t.Fatalf("incorrect prev chan: expected %v, got %v",
|
|
gokuPrevChan.ChannelID, route.Hops[0].Channel.ChannelID)
|
|
}
|
|
gokuNextChan, ok := route.nextHopChannel(aliases["songoku"])
|
|
if !ok {
|
|
t.Fatalf("goku didn't have prev chan but should have")
|
|
}
|
|
if gokuNextChan.ChannelID != route.Hops[1].Channel.ChannelID {
|
|
t.Fatalf("incorrect prev chan: expected %v, got %v",
|
|
gokuNextChan.ChannelID, route.Hops[1].Channel.ChannelID)
|
|
}
|
|
|
|
// Sophon shouldn't have a next chan, but she should have a prev chan.
|
|
if _, ok := route.nextHopChannel(aliases["sophon"]); ok {
|
|
t.Fatalf("incorrect next hop map, no vertexes should " +
|
|
"be after sophon")
|
|
}
|
|
sophonPrevEdge, ok := route.prevHopChannel(aliases["sophon"])
|
|
if !ok {
|
|
t.Fatalf("sophon didn't have prev chan but should have")
|
|
}
|
|
if sophonPrevEdge.ChannelID != route.Hops[1].Channel.ChannelID {
|
|
t.Fatalf("incorrect prev chan: expected %v, got %v",
|
|
sophonPrevEdge.ChannelID, route.Hops[1].Channel.ChannelID)
|
|
}
|
|
|
|
// Next, attempt to query for a path to Luo Ji for 100 satoshis, there
|
|
// exist two possible paths in the graph, but the shorter (1 hop) path
|
|
// should be selected.
|
|
target = aliases["luoji"]
|
|
path, err = findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, paymentAmt, nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to find route: %v", err)
|
|
}
|
|
|
|
route, err = newRoute(
|
|
paymentAmt, noFeeLimit, sourceVertex, path, startingHeight,
|
|
finalHopCLTV,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to create path: %v", err)
|
|
}
|
|
|
|
// The length of the path should be exactly one hop as it's the
|
|
// "shortest" known path in the graph.
|
|
if len(route.Hops) != 1 {
|
|
t.Fatalf("shortest path not selected, should be of length 1, "+
|
|
"is instead: %v", len(route.Hops))
|
|
}
|
|
|
|
// As we have a direct path, the total time lock value should be
|
|
// exactly the current block height plus one.
|
|
if route.TotalTimeLock != 101 {
|
|
t.Fatalf("expected time lock of %v, instead have %v", 1,
|
|
route.TotalTimeLock)
|
|
}
|
|
|
|
// Additionally, since this is a single-hop payment, we shouldn't have
|
|
// to pay any fees in total, so the total amount should be the payment
|
|
// amount.
|
|
if route.TotalAmount != paymentAmt {
|
|
t.Fatalf("incorrect total amount, expected %v got %v",
|
|
paymentAmt, route.TotalAmount)
|
|
}
|
|
}
|
|
|
|
func TestPathFindingWithAdditionalEdges(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
|
|
paymentAmt := lnwire.NewMSatFromSatoshis(100)
|
|
|
|
// In this test, we'll test that we're able to find paths through
|
|
// private channels when providing them as additional edges in our path
|
|
// finding algorithm. To do so, we'll create a new node, doge, and
|
|
// create a private channel between it and songoku. We'll then attempt
|
|
// to find a path from our source node, roasbeef, to doge.
|
|
dogePubKeyHex := "03dd46ff29a6941b4a2607525b043ec9b020b3f318a1bf281536fd7011ec59c882"
|
|
dogePubKeyBytes, err := hex.DecodeString(dogePubKeyHex)
|
|
if err != nil {
|
|
t.Fatalf("unable to decode public key: %v", err)
|
|
}
|
|
dogePubKey, err := btcec.ParsePubKey(dogePubKeyBytes, btcec.S256())
|
|
if err != nil {
|
|
t.Fatalf("unable to parse public key from bytes: %v", err)
|
|
}
|
|
|
|
doge := &channeldb.LightningNode{}
|
|
doge.AddPubKey(dogePubKey)
|
|
doge.Alias = "doge"
|
|
|
|
// Create the channel edge going from songoku to doge and include it in
|
|
// our map of additional edges.
|
|
songokuToDoge := &channeldb.ChannelEdgePolicy{
|
|
Node: doge,
|
|
ChannelID: 1337,
|
|
FeeBaseMSat: 1,
|
|
FeeProportionalMillionths: 1000,
|
|
TimeLockDelta: 9,
|
|
}
|
|
|
|
additionalEdges := map[Vertex][]*channeldb.ChannelEdgePolicy{
|
|
NewVertex(aliases["songoku"]): {songokuToDoge},
|
|
}
|
|
|
|
// We should now be able to find a path from roasbeef to doge.
|
|
path, err := findPath(
|
|
nil, graph, additionalEdges, sourceNode, dogePubKey, nil, nil,
|
|
paymentAmt, nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to find private path to doge: %v", err)
|
|
}
|
|
|
|
// The path should represent the following hops:
|
|
// roasbeef -> songoku -> doge
|
|
assertExpectedPath(t, path, "songoku", "doge")
|
|
}
|
|
|
|
func TestKShortestPathFinding(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
|
|
// In this test we'd like to ensure that our algorithm to find the
|
|
// k-shortest paths from a given source node to any destination node
|
|
// works as expected.
|
|
|
|
// In our basic_graph.json, there exist two paths from roasbeef to luo
|
|
// ji. Our algorithm should properly find both paths, and also rank
|
|
// them in order of their total "distance".
|
|
|
|
paymentAmt := lnwire.NewMSatFromSatoshis(100)
|
|
target := aliases["luoji"]
|
|
paths, err := findPaths(
|
|
nil, graph, sourceNode, target, paymentAmt, 100,
|
|
nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to find paths between roasbeef and "+
|
|
"luo ji: %v", err)
|
|
}
|
|
|
|
// The algorithm should have found two paths from roasbeef to luo ji.
|
|
if len(paths) != 2 {
|
|
t.Fatalf("two path shouldn't been found, instead %v were",
|
|
len(paths))
|
|
}
|
|
|
|
// Additionally, the total hop length of the first path returned should
|
|
// be _less_ than that of the second path returned.
|
|
if len(paths[0]) > len(paths[1]) {
|
|
t.Fatalf("paths found not ordered properly")
|
|
}
|
|
|
|
// The first route should be a direct route to luo ji.
|
|
assertExpectedPath(t, paths[0], "roasbeef", "luoji")
|
|
|
|
// The second route should be a route to luo ji via satoshi.
|
|
assertExpectedPath(t, paths[1], "roasbeef", "satoshi", "luoji")
|
|
}
|
|
|
|
// TestNewRoute tests whether the construction of hop payloads by newRoute
|
|
// is executed correctly.
|
|
func TestNewRoute(t *testing.T) {
|
|
|
|
var sourceKey [33]byte
|
|
sourceVertex := Vertex(sourceKey)
|
|
|
|
const (
|
|
startingHeight = 100
|
|
finalHopCLTV = 1
|
|
)
|
|
|
|
createHop := func(baseFee lnwire.MilliSatoshi,
|
|
feeRate lnwire.MilliSatoshi,
|
|
capacity btcutil.Amount,
|
|
timeLockDelta uint16) (*ChannelHop) {
|
|
|
|
return &ChannelHop {
|
|
ChannelEdgePolicy: &channeldb.ChannelEdgePolicy {
|
|
Node: &channeldb.LightningNode{},
|
|
FeeProportionalMillionths: feeRate,
|
|
FeeBaseMSat: baseFee,
|
|
TimeLockDelta: timeLockDelta,
|
|
},
|
|
Capacity: capacity,
|
|
}
|
|
}
|
|
|
|
testCases := []struct {
|
|
// name identifies the test case in the test output.
|
|
name string
|
|
|
|
// hops is the list of hops (the route) that gets passed into
|
|
// the call to newRoute.
|
|
hops []*ChannelHop
|
|
|
|
// paymentAmount is the amount that is send into the route
|
|
// indicated by hops.
|
|
paymentAmount lnwire.MilliSatoshi
|
|
|
|
// expectedFees is a list of fees that every hop is expected
|
|
// to charge for forwarding.
|
|
expectedFees []lnwire.MilliSatoshi
|
|
|
|
// expectedTimeLocks is a list of time lock values that every
|
|
// hop is expected to specify in its outgoing HTLC. The time
|
|
// lock values in this list are relative to the current block
|
|
// height.
|
|
expectedTimeLocks []uint32
|
|
|
|
// expectedTotalAmount is the total amount that is expected to
|
|
// be returned from newRoute. This amount should include all
|
|
// the fees to be paid to intermediate hops.
|
|
expectedTotalAmount lnwire.MilliSatoshi
|
|
|
|
// expectedTotalTimeLock is the time lock that is expected to
|
|
// be returned from newRoute. This is the time lock that should
|
|
// be specified in the HTLC that is sent by the source node.
|
|
// expectedTotalTimeLock is relative to the current block height.
|
|
expectedTotalTimeLock uint32
|
|
|
|
// expectError indicates whether the newRoute call is expected
|
|
// to fail or succeed.
|
|
expectError bool
|
|
|
|
// expectedErrorCode indicates the expected error code when
|
|
// expectError is true.
|
|
expectedErrorCode errorCode
|
|
} {
|
|
{
|
|
// For a single hop payment, no fees are expected to be paid.
|
|
name: "single hop",
|
|
paymentAmount: 100000,
|
|
hops: []*ChannelHop {
|
|
createHop(100, 1000, 1000, 10),
|
|
},
|
|
expectedFees: []lnwire.MilliSatoshi {0},
|
|
expectedTimeLocks: []uint32 {1},
|
|
expectedTotalAmount: 100000,
|
|
expectedTotalTimeLock: 1,
|
|
}, {
|
|
// For a two hop payment, only the fee for the first hop
|
|
// needs to be paid. The destination hop does not require
|
|
// a fee to receive the payment.
|
|
name: "two hop",
|
|
paymentAmount: 100000,
|
|
hops: []*ChannelHop {
|
|
createHop(0, 1000, 1000, 10),
|
|
createHop(30, 1000, 1000, 5),
|
|
},
|
|
expectedFees: []lnwire.MilliSatoshi {130, 0},
|
|
expectedTimeLocks: []uint32 {1, 1},
|
|
expectedTotalAmount: 100130,
|
|
expectedTotalTimeLock: 6,
|
|
}, {
|
|
// Insufficient capacity in first channel when fees are added.
|
|
name: "two hop insufficient",
|
|
paymentAmount: 100000,
|
|
hops: []*ChannelHop {
|
|
createHop(0, 1000, 100, 10),
|
|
createHop(0, 1000, 1000, 5),
|
|
},
|
|
expectError: true,
|
|
expectedErrorCode: ErrInsufficientCapacity,
|
|
}, {
|
|
// A three hop payment where the first and second hop
|
|
// will both charge 1 msat. The fee for the first hop
|
|
// is actually slightly higher than 1, because the amount
|
|
// to forward also includes the fee for the second hop. This
|
|
// gets rounded down to 1.
|
|
name: "three hop",
|
|
paymentAmount: 100000,
|
|
hops: []*ChannelHop {
|
|
createHop(0, 10, 1000, 10),
|
|
createHop(0, 10, 1000, 5),
|
|
createHop(0, 10, 1000, 3),
|
|
},
|
|
expectedFees: []lnwire.MilliSatoshi {1, 1, 0},
|
|
expectedTotalAmount: 100002,
|
|
expectedTimeLocks: []uint32 {4, 1, 1},
|
|
expectedTotalTimeLock: 9,
|
|
}, {
|
|
// A three hop payment where the fee of the first hop
|
|
// is slightly higher (11) than the fee at the second hop,
|
|
// because of the increase amount to forward.
|
|
name: "three hop with fee carry over",
|
|
paymentAmount: 100000,
|
|
hops: []*ChannelHop {
|
|
createHop(0, 10000, 1000, 10),
|
|
createHop(0, 10000, 1000, 5),
|
|
createHop(0, 10000, 1000, 3),
|
|
},
|
|
expectedFees: []lnwire.MilliSatoshi {1010, 1000, 0},
|
|
expectedTotalAmount: 102010,
|
|
expectedTimeLocks: []uint32 {4, 1, 1},
|
|
expectedTotalTimeLock: 9,
|
|
}, {
|
|
// A three hop payment where the fee policies of the first and
|
|
// second hop are just high enough to show the fee carry over
|
|
// effect.
|
|
name: "three hop with minimal fees for carry over",
|
|
paymentAmount: 100000,
|
|
hops: []*ChannelHop {
|
|
createHop(0, 10000, 1000, 10),
|
|
|
|
// First hop charges 0.1% so the second hop fee
|
|
// should show up in the first hop fee as 1 msat
|
|
// extra.
|
|
createHop(0, 1000, 1000, 5),
|
|
|
|
// Second hop charges a fixed 1000 msat.
|
|
createHop(1000, 0, 1000, 3),
|
|
},
|
|
expectedFees: []lnwire.MilliSatoshi {101, 1000, 0},
|
|
expectedTotalAmount: 101101,
|
|
expectedTimeLocks: []uint32 {4, 1, 1},
|
|
expectedTotalTimeLock: 9,
|
|
} }
|
|
|
|
for _, testCase := range testCases {
|
|
assertRoute := func(t *testing.T, route *Route) {
|
|
if route.TotalAmount != testCase.expectedTotalAmount {
|
|
t.Errorf("Expected total amount is be %v" +
|
|
", but got %v instead",
|
|
testCase.expectedTotalAmount,
|
|
route.TotalAmount)
|
|
}
|
|
|
|
for i := 0; i < len(testCase.expectedFees); i++ {
|
|
if testCase.expectedFees[i] !=
|
|
route.Hops[i].Fee {
|
|
|
|
t.Errorf("Expected fee for hop %v to " +
|
|
"be %v, but got %v instead",
|
|
i, testCase.expectedFees[i],
|
|
route.Hops[i].Fee)
|
|
}
|
|
}
|
|
|
|
expectedTimeLockHeight := startingHeight +
|
|
testCase.expectedTotalTimeLock
|
|
|
|
if route.TotalTimeLock != expectedTimeLockHeight {
|
|
|
|
t.Errorf("Expected total time lock to be %v" +
|
|
", but got %v instead",
|
|
expectedTimeLockHeight,
|
|
route.TotalTimeLock)
|
|
}
|
|
|
|
for i := 0; i < len(testCase.expectedTimeLocks); i++ {
|
|
expectedTimeLockHeight := startingHeight +
|
|
testCase.expectedTimeLocks[i]
|
|
|
|
if expectedTimeLockHeight !=
|
|
route.Hops[i].OutgoingTimeLock {
|
|
|
|
t.Errorf("Expected time lock for hop " +
|
|
"%v to be %v, but got %v instead",
|
|
i, expectedTimeLockHeight,
|
|
route.Hops[i].OutgoingTimeLock)
|
|
}
|
|
}
|
|
}
|
|
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
route, err := newRoute(testCase.paymentAmount,
|
|
noFeeLimit,
|
|
sourceVertex, testCase.hops, startingHeight,
|
|
finalHopCLTV)
|
|
|
|
if testCase.expectError {
|
|
expectedCode := testCase.expectedErrorCode
|
|
if err == nil || !IsError(err, expectedCode) {
|
|
t.Errorf("expected newRoute to fail " +
|
|
"with error code %v, but got" +
|
|
"%v instead",
|
|
expectedCode, err)
|
|
}
|
|
} else {
|
|
if err != nil {
|
|
t.Errorf("unable to create path: %v", err)
|
|
}
|
|
|
|
assertRoute(t, route)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNewRoutePathTooLong(t *testing.T) {
|
|
t.Skip()
|
|
|
|
// Ensure that potential paths which are over the maximum hop-limit are
|
|
// rejected.
|
|
graph, cleanUp, aliases, err := parseTestGraph(excessiveHopsGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
ignoredVertexes := make(map[Vertex]struct{})
|
|
|
|
paymentAmt := lnwire.NewMSatFromSatoshis(100)
|
|
|
|
// We start by confirming that routing a payment 20 hops away is possible.
|
|
// Alice should be able to find a valid route to ursula.
|
|
target := aliases["ursula"]
|
|
_, err = findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, paymentAmt, nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("path should have been found")
|
|
}
|
|
|
|
// Vincent is 21 hops away from Alice, and thus no valid route should be
|
|
// presented to Alice.
|
|
target = aliases["vincent"]
|
|
path, err := findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, paymentAmt, nil,
|
|
)
|
|
if err == nil {
|
|
t.Fatalf("should not have been able to find path, supposed to be "+
|
|
"greater than 20 hops, found route with %v hops",
|
|
len(path))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathNotAvailable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, _, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
ignoredVertexes := make(map[Vertex]struct{})
|
|
|
|
// With the test graph loaded, we'll test that queries for target that
|
|
// are either unreachable within the graph, or unknown result in an
|
|
// error.
|
|
unknownNodeStr := "03dd46ff29a6941b4a2607525b043ec9b020b3f318a1bf281536fd7011ec59c882"
|
|
unknownNodeBytes, err := hex.DecodeString(unknownNodeStr)
|
|
if err != nil {
|
|
t.Fatalf("unable to parse bytes: %v", err)
|
|
}
|
|
unknownNode, err := btcec.ParsePubKey(unknownNodeBytes, btcec.S256())
|
|
if err != nil {
|
|
t.Fatalf("unable to parse pubkey: %v", err)
|
|
}
|
|
|
|
_, err = findPath(
|
|
nil, graph, nil, sourceNode, unknownNode, ignoredVertexes,
|
|
ignoredEdges, 100, nil,
|
|
)
|
|
if !IsError(err, ErrNoPathFound) {
|
|
t.Fatalf("path shouldn't have been found: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPathInsufficientCapacity(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
ignoredVertexes := make(map[Vertex]struct{})
|
|
|
|
// Next, test that attempting to find a path in which the current
|
|
// channel graph cannot support due to insufficient capacity triggers
|
|
// an error.
|
|
|
|
// To test his we'll attempt to make a payment of 1 BTC, or 100 million
|
|
// satoshis. The largest channel in the basic graph is of size 100k
|
|
// satoshis, so we shouldn't be able to find a path to sophon even
|
|
// though we have a 2-hop link.
|
|
target := aliases["sophon"]
|
|
|
|
payAmt := lnwire.NewMSatFromSatoshis(btcutil.SatoshiPerBitcoin)
|
|
_, err = findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, payAmt, nil,
|
|
)
|
|
if !IsError(err, ErrNoPathFound) {
|
|
t.Fatalf("graph shouldn't be able to support payment: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestRouteFailMinHTLC tests that if we attempt to route an HTLC which is
|
|
// smaller than the advertised minHTLC of an edge, then path finding fails.
|
|
func TestRouteFailMinHTLC(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
ignoredVertexes := make(map[Vertex]struct{})
|
|
|
|
// We'll not attempt to route an HTLC of 10 SAT from roasbeef to Son
|
|
// Goku. However, the min HTLC of Son Goku is 1k SAT, as a result, this
|
|
// attempt should fail.
|
|
target := aliases["songoku"]
|
|
payAmt := lnwire.MilliSatoshi(10)
|
|
_, err = findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, payAmt, nil,
|
|
)
|
|
if !IsError(err, ErrNoPathFound) {
|
|
t.Fatalf("graph shouldn't be able to support payment: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestRouteFailDisabledEdge tests that if we attempt to route to an edge
|
|
// that's disabled, then that edge is disqualified, and the routing attempt
|
|
// will fail.
|
|
func TestRouteFailDisabledEdge(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
ignoredVertexes := make(map[Vertex]struct{})
|
|
|
|
// First, we'll try to route from roasbeef -> songoku. This should
|
|
// succeed without issue, and return a single path.
|
|
target := aliases["songoku"]
|
|
payAmt := lnwire.NewMSatFromSatoshis(10000)
|
|
_, err = findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, payAmt, nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to find path: %v", err)
|
|
}
|
|
|
|
// First, we'll modify the edge from roasbeef -> songoku, to read that
|
|
// it's disabled.
|
|
_, gokuEdge, _, err := graph.FetchChannelEdgesByID(12345)
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch goku's edge: %v", err)
|
|
}
|
|
gokuEdge.Flags = lnwire.ChanUpdateDisabled
|
|
if err := graph.UpdateEdgePolicy(gokuEdge); err != nil {
|
|
t.Fatalf("unable to update edge: %v", err)
|
|
}
|
|
|
|
// Now, if we attempt to route through that edge, we should get a
|
|
// failure as it is no longer eligible.
|
|
_, err = findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertexes,
|
|
ignoredEdges, payAmt, nil,
|
|
)
|
|
if !IsError(err, ErrNoPathFound) {
|
|
t.Fatalf("graph shouldn't be able to support payment: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestRouteExceededFeeLimit tests that routes respect the fee limit imposed.
|
|
func TestRouteExceededFeeLimit(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
graph, cleanUp, aliases, err := parseTestGraph(basicGraphFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create graph: %v", err)
|
|
}
|
|
|
|
sourceNode, err := graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to fetch source node: %v", err)
|
|
}
|
|
sourceVertex := Vertex(sourceNode.PubKeyBytes)
|
|
|
|
ignoredVertices := make(map[Vertex]struct{})
|
|
ignoredEdges := make(map[uint64]struct{})
|
|
|
|
// Find a path to send 100 satoshis from roasbeef to sophon.
|
|
target := aliases["sophon"]
|
|
amt := lnwire.NewMSatFromSatoshis(100)
|
|
path, err := findPath(
|
|
nil, graph, nil, sourceNode, target, ignoredVertices,
|
|
ignoredEdges, amt, nil,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("unable to find path from roasbeef to phamnuwen for "+
|
|
"100 satoshis: %v", err)
|
|
}
|
|
|
|
// We'll now purposefully set a fee limit of 0 to trigger the exceeded
|
|
// fee limit error. This should work since the path retrieved spans
|
|
// multiple hops incurring a fee.
|
|
feeLimit := lnwire.NewMSatFromSatoshis(0)
|
|
|
|
_, err = newRoute(amt, feeLimit, sourceVertex, path, 100, 1)
|
|
if !IsError(err, ErrFeeLimitExceeded) {
|
|
t.Fatalf("route should've exceeded fee limit: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPathInsufficientCapacityWithFee(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// TODO(roasbeef): encode live graph to json
|
|
|
|
// TODO(roasbeef): need to add a case, or modify the fee ratio for one
|
|
// to ensure that has going forward, but when fees are applied doesn't
|
|
// work
|
|
}
|
|
|
|
func TestPathFindSpecExample(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// All our path finding tests will assume a starting height of 100, so
|
|
// we'll pass that in to ensure that the router uses 100 as the current
|
|
// height.
|
|
const startingHeight = 100
|
|
ctx, cleanUp, err := createTestCtx(startingHeight, specExampleFilePath)
|
|
defer cleanUp()
|
|
if err != nil {
|
|
t.Fatalf("unable to create router: %v", err)
|
|
}
|
|
|
|
const (
|
|
aliceFinalCLTV = 10
|
|
bobFinalCLTV = 20
|
|
carolFinalCLTV = 30
|
|
daveFinalCLTV = 40
|
|
)
|
|
|
|
// We'll first exercise the scenario of a direct payment from Bob to
|
|
// Carol, so we set "B" as the source node so path finding starts from
|
|
// Bob.
|
|
bob := ctx.aliases["B"]
|
|
bobNode, err := ctx.graph.FetchLightningNode(bob)
|
|
if err != nil {
|
|
t.Fatalf("unable to find bob: %v", err)
|
|
}
|
|
if err := ctx.graph.SetSourceNode(bobNode); err != nil {
|
|
t.Fatalf("unable to set source node: %v", err)
|
|
}
|
|
|
|
// Query for a route of 4,999,999 mSAT to carol.
|
|
carol := ctx.aliases["C"]
|
|
const amt lnwire.MilliSatoshi = 4999999
|
|
routes, err := ctx.router.FindRoutes(carol, amt, noFeeLimit, 100)
|
|
if err != nil {
|
|
t.Fatalf("unable to find route: %v", err)
|
|
}
|
|
|
|
// We should come back with _exactly_ two routes.
|
|
if len(routes) != 2 {
|
|
t.Fatalf("expected %v routes, instead have: %v", 2,
|
|
len(routes))
|
|
}
|
|
|
|
// Now we'll examine the first route returned for correctness.
|
|
//
|
|
// It should be sending the exact payment amount as there are no
|
|
// additional hops.
|
|
firstRoute := routes[0]
|
|
if firstRoute.TotalAmount != amt {
|
|
t.Fatalf("wrong total amount: got %v, expected %v",
|
|
firstRoute.TotalAmount, amt)
|
|
}
|
|
if firstRoute.Hops[0].AmtToForward != amt {
|
|
t.Fatalf("wrong forward amount: got %v, expected %v",
|
|
firstRoute.Hops[0].AmtToForward, amt)
|
|
}
|
|
if firstRoute.Hops[0].Fee != 0 {
|
|
t.Fatalf("wrong hop fee: got %v, expected %v",
|
|
firstRoute.Hops[0].Fee, 0)
|
|
}
|
|
|
|
// The CLTV expiry should be the current height plus 9 (the expiry for
|
|
// the B -> C channel.
|
|
if firstRoute.TotalTimeLock !=
|
|
startingHeight+DefaultFinalCLTVDelta {
|
|
|
|
t.Fatalf("wrong total time lock: got %v, expecting %v",
|
|
firstRoute.TotalTimeLock,
|
|
startingHeight+DefaultFinalCLTVDelta)
|
|
}
|
|
|
|
// Next, we'll set A as the source node so we can assert that we create
|
|
// the proper route for any queries starting with Alice.
|
|
alice := ctx.aliases["A"]
|
|
aliceNode, err := ctx.graph.FetchLightningNode(alice)
|
|
if err != nil {
|
|
t.Fatalf("unable to find alice: %v", err)
|
|
}
|
|
if err := ctx.graph.SetSourceNode(aliceNode); err != nil {
|
|
t.Fatalf("unable to set source node: %v", err)
|
|
}
|
|
ctx.router.selfNode = aliceNode
|
|
source, err := ctx.graph.SourceNode()
|
|
if err != nil {
|
|
t.Fatalf("unable to retrieve source node: %v", err)
|
|
}
|
|
if !bytes.Equal(source.PubKeyBytes[:], alice.SerializeCompressed()) {
|
|
t.Fatalf("source node not set")
|
|
}
|
|
|
|
// We'll now request a route from A -> B -> C.
|
|
ctx.router.routeCache = make(map[routeTuple][]*Route)
|
|
routes, err = ctx.router.FindRoutes(carol, amt, noFeeLimit, 100)
|
|
if err != nil {
|
|
t.Fatalf("unable to find routes: %v", err)
|
|
}
|
|
|
|
// We should come back with _exactly_ two routes.
|
|
if len(routes) != 2 {
|
|
t.Fatalf("expected %v routes, instead have: %v", 2,
|
|
len(routes))
|
|
}
|
|
|
|
// Both routes should be two hops.
|
|
if len(routes[0].Hops) != 2 {
|
|
t.Fatalf("route should be %v hops, is instead %v", 2,
|
|
len(routes[0].Hops))
|
|
}
|
|
if len(routes[1].Hops) != 2 {
|
|
t.Fatalf("route should be %v hops, is instead %v", 2,
|
|
len(routes[1].Hops))
|
|
}
|
|
|
|
// The total amount should factor in a fee of 10199 and also use a CLTV
|
|
// delta total of 29 (20 + 9),
|
|
expectedAmt := lnwire.MilliSatoshi(5010198)
|
|
if routes[0].TotalAmount != expectedAmt {
|
|
t.Fatalf("wrong amount: got %v, expected %v",
|
|
routes[0].TotalAmount, expectedAmt)
|
|
}
|
|
if routes[0].TotalTimeLock != startingHeight+29 {
|
|
t.Fatalf("wrong total time lock: got %v, expecting %v",
|
|
routes[0].TotalTimeLock, startingHeight+29)
|
|
}
|
|
|
|
// Ensure that the hops of the first route are properly crafted.
|
|
//
|
|
// After taking the fee, Bob should be forwarding the remainder which
|
|
// is the exact payment to Bob.
|
|
if routes[0].Hops[0].AmtToForward != amt {
|
|
t.Fatalf("wrong forward amount: got %v, expected %v",
|
|
routes[0].Hops[0].AmtToForward, amt)
|
|
}
|
|
|
|
// We shouldn't pay any fee for the first, hop, but the fee for the
|
|
// second hop posted fee should be exactly:
|
|
|
|
// The fee that we pay for the second hop will be "applied to the first
|
|
// hop, so we should get a fee of exactly:
|
|
//
|
|
// * 200 + 4999999 * 2000 / 1000000 = 10199
|
|
if routes[0].Hops[0].Fee != 10199 {
|
|
t.Fatalf("wrong hop fee: got %v, expected %v",
|
|
routes[0].Hops[0].Fee, 10199)
|
|
}
|
|
|
|
// While for the final hop, as there's no additional hop afterwards, we
|
|
// pay no fee.
|
|
if routes[0].Hops[1].Fee != 0 {
|
|
t.Fatalf("wrong hop fee: got %v, expected %v",
|
|
routes[0].Hops[0].Fee, 0)
|
|
}
|
|
|
|
// The outgoing CLTV value itself should be the current height plus 30
|
|
// to meet Carol's requirements.
|
|
if routes[0].Hops[0].OutgoingTimeLock !=
|
|
startingHeight+DefaultFinalCLTVDelta {
|
|
|
|
t.Fatalf("wrong total time lock: got %v, expecting %v",
|
|
routes[0].Hops[0].OutgoingTimeLock,
|
|
startingHeight+DefaultFinalCLTVDelta)
|
|
}
|
|
|
|
// For B -> C, we assert that the final hop also has the proper
|
|
// parameters.
|
|
lastHop := routes[0].Hops[1]
|
|
if lastHop.AmtToForward != amt {
|
|
t.Fatalf("wrong forward amount: got %v, expected %v",
|
|
lastHop.AmtToForward, amt)
|
|
}
|
|
if lastHop.OutgoingTimeLock !=
|
|
startingHeight+DefaultFinalCLTVDelta {
|
|
|
|
t.Fatalf("wrong total time lock: got %v, expecting %v",
|
|
lastHop.OutgoingTimeLock,
|
|
startingHeight+DefaultFinalCLTVDelta)
|
|
}
|
|
|
|
// We'll also make similar assertions for the second route from A to C
|
|
// via D.
|
|
secondRoute := routes[1]
|
|
expectedAmt = 5020398
|
|
if secondRoute.TotalAmount != expectedAmt {
|
|
t.Fatalf("wrong amount: got %v, expected %v",
|
|
secondRoute.TotalAmount, expectedAmt)
|
|
}
|
|
expectedTimeLock := startingHeight + daveFinalCLTV + DefaultFinalCLTVDelta
|
|
if secondRoute.TotalTimeLock != uint32(expectedTimeLock) {
|
|
t.Fatalf("wrong total time lock: got %v, expecting %v",
|
|
secondRoute.TotalTimeLock, expectedTimeLock)
|
|
}
|
|
onionPayload := secondRoute.Hops[0]
|
|
if onionPayload.AmtToForward != amt {
|
|
t.Fatalf("wrong forward amount: got %v, expected %v",
|
|
onionPayload.AmtToForward, amt)
|
|
}
|
|
expectedTimeLock = startingHeight + DefaultFinalCLTVDelta
|
|
if onionPayload.OutgoingTimeLock != uint32(expectedTimeLock) {
|
|
t.Fatalf("wrong outgoing time lock: got %v, expecting %v",
|
|
onionPayload.OutgoingTimeLock,
|
|
expectedTimeLock)
|
|
}
|
|
|
|
// The B -> C hop should also be identical as the prior cases.
|
|
lastHop = secondRoute.Hops[1]
|
|
if lastHop.AmtToForward != amt {
|
|
t.Fatalf("wrong forward amount: got %v, expected %v",
|
|
lastHop.AmtToForward, amt)
|
|
}
|
|
if lastHop.OutgoingTimeLock !=
|
|
startingHeight+DefaultFinalCLTVDelta {
|
|
|
|
t.Fatalf("wrong total time lock: got %v, expecting %v",
|
|
lastHop.OutgoingTimeLock,
|
|
startingHeight+DefaultFinalCLTVDelta)
|
|
}
|
|
}
|
|
|
|
func assertExpectedPath(t *testing.T, path []*ChannelHop, nodeAliases ...string) {
|
|
if len(path) != len(nodeAliases) {
|
|
t.Fatal("number of hops and number of aliases do not match")
|
|
}
|
|
|
|
for i, hop := range path {
|
|
if hop.Node.Alias != nodeAliases[i] {
|
|
t.Fatalf("expected %v to be pos #%v in hop, instead "+
|
|
"%v was", nodeAliases[i], i, hop.Node.Alias)
|
|
}
|
|
}
|
|
}
|