2016-08-30 08:07:54 +03:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"fmt"
|
2016-10-15 16:47:09 +03:00
|
|
|
"golang.org/x/net/context"
|
2016-09-26 20:41:57 +03:00
|
|
|
"sync"
|
2016-09-14 05:00:47 +03:00
|
|
|
"time"
|
2016-09-26 20:40:58 +03:00
|
|
|
"github.com/davecgh/go-spew/spew"
|
2016-10-15 16:47:09 +03:00
|
|
|
"github.com/go-errors/errors"
|
2016-09-15 22:24:52 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnrpc"
|
2016-08-30 08:07:54 +03:00
|
|
|
"github.com/roasbeef/btcd/rpctest"
|
|
|
|
"github.com/roasbeef/btcd/wire"
|
2016-08-31 05:36:33 +03:00
|
|
|
"github.com/roasbeef/btcrpcclient"
|
2016-08-30 08:07:54 +03:00
|
|
|
"github.com/roasbeef/btcutil"
|
2016-10-15 16:24:56 +03:00
|
|
|
"google.golang.org/grpc"
|
2016-10-15 16:47:09 +03:00
|
|
|
"testing"
|
2016-08-30 08:07:54 +03:00
|
|
|
)
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
// CT is needed for:
|
|
|
|
// - have uniform way of handling panic and fatal error from test cases.
|
|
|
|
// - have ability to properly wrap errors in order to see stack trace.
|
|
|
|
// - have nice and elegant way to handle lnd process errors in one
|
|
|
|
// select structure with test cases.
|
|
|
|
type CT struct {
|
|
|
|
*testing.T
|
|
|
|
|
|
|
|
// Channel for sending retransmitted panic errors and fatal error which
|
|
|
|
// happens in test case.
|
|
|
|
errChan chan error
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewCT(t *testing.T) *CT {
|
|
|
|
return &CT{t, nil}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ct *CT) Error(err error) {
|
|
|
|
if ct.errChan != nil {
|
|
|
|
ct.errChan <- fmt.Errorf(errors.Wrap(err, 1).ErrorStack())
|
|
|
|
ct.FailNow()
|
|
|
|
} else {
|
|
|
|
ct.Fatal("can't sen error when test isn't running")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Errorf create and send the description about the error in the error channel
|
|
|
|
// and exit.
|
|
|
|
func (ct *CT) Errorf(format string, a ...interface{}) {
|
|
|
|
if ct.errChan != nil {
|
|
|
|
description := fmt.Sprintf(format, a...)
|
|
|
|
ct.errChan <- fmt.Errorf(errors.Wrap(description, 1).ErrorStack())
|
|
|
|
ct.FailNow()
|
|
|
|
} else {
|
|
|
|
ct.Fatal("can't sen error when test isn't running")
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// RunTest wraps test case function in goroutine and also redirects the panic
|
|
|
|
// error from test case into error channel.
|
|
|
|
func (ct *CT) RunTest(net *networkHarness, test testCase) chan error {
|
|
|
|
// a channel to signal that test was exited with error
|
|
|
|
ct.errChan = make(chan error)
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
defer func() {
|
|
|
|
if err := recover(); err != nil {
|
|
|
|
// Retransmit test panic into main "process"
|
|
|
|
ct.errChan <- fmt.Errorf(err.(string))
|
|
|
|
}
|
|
|
|
close(ct.errChan)
|
|
|
|
ct.errChan = nil
|
|
|
|
}()
|
|
|
|
test(net, ct)
|
|
|
|
}()
|
|
|
|
|
|
|
|
return ct.errChan
|
|
|
|
}
|
|
|
|
|
|
|
|
func assertTxInBlock(ct *CT, block *btcutil.Block, txid *wire.ShaHash) {
|
2016-08-30 08:07:54 +03:00
|
|
|
for _, tx := range block.Transactions() {
|
|
|
|
if bytes.Equal(txid[:], tx.Sha()[:]) {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("funding tx was not included in block")
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:24:56 +03:00
|
|
|
// mineBlocks mine 'num' of blocks and check that blocks are present in
|
|
|
|
// node blockchain.
|
|
|
|
func mineBlocks(ct *CT, net *networkHarness, num uint32) []*btcutil.Block {
|
|
|
|
blocks := make([]*btcutil.Block, num)
|
|
|
|
|
|
|
|
blockHashes, err := net.Miner.Node.Generate(num)
|
|
|
|
if err != nil {
|
|
|
|
ct.Errorf("unable to generate blocks: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, blockHash := range blockHashes {
|
|
|
|
block, err := net.Miner.Node.GetBlock(blockHash)
|
|
|
|
if err != nil {
|
|
|
|
ct.Errorf("unable to get block: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
blocks[i] = block
|
|
|
|
}
|
|
|
|
|
|
|
|
return blocks
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
// openChannelAndAssert attempts to open a channel with the specified
|
|
|
|
// parameters extended from Alice to Bob. Additionally, two items are asserted
|
2016-10-15 16:47:09 +03:00
|
|
|
// after the channel is considered open: the funding transaction should be
|
2016-09-18 03:34:39 +03:00
|
|
|
// found within a block, and that Alice can report the status of the new
|
|
|
|
// channel.
|
2016-10-15 16:47:09 +03:00
|
|
|
func openChannelAndAssert(ct *CT, net *networkHarness, ctx context.Context,
|
2016-09-18 03:34:39 +03:00
|
|
|
alice, bob *lightningNode, amount btcutil.Amount) *lnrpc.ChannelPoint {
|
|
|
|
|
|
|
|
chanOpenUpdate, err := net.OpenChannel(ctx, alice, bob, amount, 1)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to open channel: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
// Mine a block, then wait for Alice's node to notify us that the
|
|
|
|
// channel has been opened. The funding transaction should be found
|
|
|
|
// within the newly mined block.
|
2016-10-15 16:24:56 +03:00
|
|
|
block := mineBlocks(ct, net, 1)[0]
|
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
fundingChanPoint, err := net.WaitForChannelOpen(ctx, chanOpenUpdate)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("error while waiting for channel open: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
|
|
|
fundingTxID, err := wire.NewShaHash(fundingChanPoint.FundingTxid)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create sha hash: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
assertTxInBlock(ct, block, fundingTxID)
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
// The channel should be listed in the peer information returned by
|
|
|
|
// both peers.
|
|
|
|
chanPoint := wire.OutPoint{
|
|
|
|
Hash: *fundingTxID,
|
|
|
|
Index: fundingChanPoint.OutputIndex,
|
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
if err := net.AssertChannelExists(ctx, alice, &chanPoint); err != nil {
|
|
|
|
ct.Errorf("unable to assert channel existence: %v", err)
|
2016-09-15 21:59:51 +03:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
return fundingChanPoint
|
|
|
|
}
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
// closeChannelAndAssert attempts to close a channel identified by the passed
|
2016-09-18 03:34:39 +03:00
|
|
|
// channel point owned by the passed lighting node. A fully blocking channel
|
|
|
|
// closure is attempted, therefore the passed context should be a child derived
|
|
|
|
// via timeout from a base parent. Additionally, once the channel has been
|
|
|
|
// detected as closed, an assertion checks that the transaction is found within
|
|
|
|
// a block.
|
2016-10-15 16:47:09 +03:00
|
|
|
func closeChannelAndAssert(ct *CT, net *networkHarness, ctx context.Context,
|
|
|
|
node *lightningNode, fundingChanPoint *lnrpc.ChannelPoint) {
|
2016-09-18 03:34:39 +03:00
|
|
|
|
|
|
|
closeUpdates, err := net.CloseChannel(ctx, node, fundingChanPoint, false)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to close channel: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
// Finally, generate a single block, wait for the final close status
|
|
|
|
// update, then ensure that the closing transaction was included in the
|
|
|
|
// block.
|
2016-10-15 16:24:56 +03:00
|
|
|
block := mineBlocks(ct, net, 1)[0]
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
closingTxid, err := net.WaitForChannelClose(ctx, closeUpdates)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("error while waiting for channel close: %v", err)
|
2016-09-15 21:59:51 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
assertTxInBlock(ct, block, closingTxid)
|
2016-09-15 21:59:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// testBasicChannelFunding performs a test exercising expected behavior from a
|
2016-08-30 08:07:54 +03:00
|
|
|
// basic funding workflow. The test creates a new channel between Alice and
|
|
|
|
// Bob, then immediately closes the channel after asserting some expected post
|
2016-09-15 21:59:51 +03:00
|
|
|
// conditions. Finally, the chain itself is checked to ensure the closing
|
2016-08-30 08:07:54 +03:00
|
|
|
// transaction was mined.
|
2016-10-15 16:47:09 +03:00
|
|
|
func testBasicChannelFunding(net *networkHarness, ct *CT) {
|
2016-09-18 03:34:39 +03:00
|
|
|
timeout := time.Duration(time.Second * 5)
|
2016-08-31 05:36:33 +03:00
|
|
|
ctxb := context.Background()
|
2016-09-15 22:24:52 +03:00
|
|
|
|
2016-08-31 21:59:08 +03:00
|
|
|
chanAmt := btcutil.Amount(btcutil.SatoshiPerBitcoin / 2)
|
2016-08-31 05:36:33 +03:00
|
|
|
|
2016-09-15 22:24:52 +03:00
|
|
|
// First establish a channel with a capacity of 0.5 BTC between Alice
|
|
|
|
// and Bob. This function will block until the channel itself is fully
|
|
|
|
// open or an error occurs in the funding process. A series of
|
|
|
|
// assertions will be executed to ensure the funding process completed
|
|
|
|
// successfully.
|
2016-09-18 03:34:39 +03:00
|
|
|
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPoint := openChannelAndAssert(ct, net, ctxt, net.Alice, net.Bob, chanAmt)
|
2016-09-15 22:24:52 +03:00
|
|
|
|
|
|
|
// Finally, immediately close the channel. This function will also
|
|
|
|
// block until the channel is closed and will additionally assert the
|
|
|
|
// relevant channel closing post conditions.
|
2016-09-18 03:34:39 +03:00
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
closeChannelAndAssert(ct, net, ctxt, net.Alice, chanPoint)
|
2016-09-15 21:59:51 +03:00
|
|
|
}
|
2016-08-30 08:07:54 +03:00
|
|
|
|
2016-09-15 21:59:51 +03:00
|
|
|
// testChannelBalance creates a new channel between Alice and Bob, then
|
|
|
|
// checks channel balance to be equal amount specified while creation of channel.
|
2016-10-15 16:47:09 +03:00
|
|
|
func testChannelBalance(net *networkHarness, ct *CT) {
|
2016-09-18 03:34:39 +03:00
|
|
|
timeout := time.Duration(time.Second * 5)
|
2016-10-15 16:47:09 +03:00
|
|
|
|
|
|
|
// Open a channel with 0.5 BTC between Alice and Bob, ensuring the
|
|
|
|
// channel has been opened properly.
|
|
|
|
amount := btcutil.Amount(btcutil.SatoshiPerBitcoin / 2)
|
|
|
|
ctx, _ := context.WithTimeout(context.Background(), timeout)
|
2016-08-31 05:36:33 +03:00
|
|
|
|
2016-09-15 22:24:52 +03:00
|
|
|
// Creates a helper closure to be used below which asserts the proper
|
|
|
|
// response to a channel balance RPC.
|
2016-10-15 16:47:09 +03:00
|
|
|
checkChannelBalance := func(node lnrpc.LightningClient,
|
|
|
|
amount btcutil.Amount) {
|
|
|
|
|
|
|
|
response, err := node.ChannelBalance(ctx, &lnrpc.ChannelBalanceRequest{})
|
2016-09-15 21:59:51 +03:00
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to get channel balance: %v", err)
|
2016-09-15 21:59:51 +03:00
|
|
|
}
|
2016-08-31 05:36:33 +03:00
|
|
|
|
2016-09-15 21:59:51 +03:00
|
|
|
balance := btcutil.Amount(response.Balance)
|
|
|
|
if balance != amount {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("channel balance wrong: %v != %v", balance,
|
|
|
|
amount)
|
2016-09-15 21:59:51 +03:00
|
|
|
}
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPoint := openChannelAndAssert(ct, net, ctx, net.Alice, net.Bob,
|
|
|
|
amount)
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-09-15 22:24:52 +03:00
|
|
|
// As this is a single funder channel, Alice's balance should be
|
|
|
|
// exactly 0.5 BTC since now state transitions have taken place yet.
|
2016-09-15 21:59:51 +03:00
|
|
|
checkChannelBalance(net.Alice, amount)
|
|
|
|
|
2016-09-15 22:24:52 +03:00
|
|
|
// Since we only explicitly wait for Alice's channel open notification,
|
|
|
|
// Bob might not yet have updated his internal state in response to
|
|
|
|
// Alice's channel open proof. So we sleep here for a second to let Bob
|
|
|
|
// catch up.
|
|
|
|
// TODO(roasbeef): Bob should also watch for the channel on-chain after
|
|
|
|
// the changes to restrict the number of pending channels are in.
|
2016-09-15 21:59:51 +03:00
|
|
|
time.Sleep(time.Second)
|
2016-09-15 22:24:52 +03:00
|
|
|
|
|
|
|
// Ensure Bob currently has no available balance within the channel.
|
2016-09-15 21:59:51 +03:00
|
|
|
checkChannelBalance(net.Bob, 0)
|
|
|
|
|
2016-09-15 22:24:52 +03:00
|
|
|
// Finally close the channel between Alice and Bob, asserting that the
|
|
|
|
// channel has been properly closed on-chain.
|
2016-10-15 16:47:09 +03:00
|
|
|
ctx, _ = context.WithTimeout(context.Background(), timeout)
|
|
|
|
closeChannelAndAssert(ct, net, ctx, net.Alice, chanPoint)
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
|
|
|
|
2016-09-15 21:59:51 +03:00
|
|
|
// testChannelForceClosure performs a test to exercise the behavior of "force"
|
|
|
|
// closing a channel or unilaterally broadcasting the latest local commitment
|
2016-09-14 05:00:47 +03:00
|
|
|
// state on-chain. The test creates a new channel between Alice and Bob, then
|
|
|
|
// force closes the channel after some cursory assertions. Within the test, two
|
|
|
|
// transactions should be broadcast on-chain, the commitment transaction itself
|
|
|
|
// (which closes the channel), and the sweep transaction a few blocks later
|
|
|
|
// once the output(s) become mature.
|
|
|
|
//
|
|
|
|
// TODO(roabeef): also add an unsettled HTLC before force closing.
|
2016-10-15 16:47:09 +03:00
|
|
|
func testChannelForceClosure(net *networkHarness, ct *CT) {
|
2016-09-18 03:34:39 +03:00
|
|
|
timeout := time.Duration(time.Second * 5)
|
2016-09-14 05:00:47 +03:00
|
|
|
ctxb := context.Background()
|
|
|
|
|
|
|
|
// First establish a channel ween with a capacity of 100k satoshis
|
|
|
|
// between Alice and Bob.
|
|
|
|
numFundingConfs := uint32(1)
|
|
|
|
chanAmt := btcutil.Amount(10e4)
|
|
|
|
chanOpenUpdate, err := net.OpenChannel(ctxb, net.Alice, net.Bob,
|
|
|
|
chanAmt, numFundingConfs)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to open channel: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
|
2016-09-14 05:00:47 +03:00
|
|
|
if _, err := net.Miner.Node.Generate(numFundingConfs); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to mine block: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
|
|
|
chanPoint, err := net.WaitForChannelOpen(ctxt, chanOpenUpdate)
|
2016-09-14 05:00:47 +03:00
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("error while waiting for channel to open: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Now that the channel is open, immediately execute a force closure of
|
|
|
|
// the channel. This will also assert that the commitment transaction
|
2016-09-15 22:24:52 +03:00
|
|
|
// was immediately broadcast in order to fulfill the force closure
|
2016-09-14 05:00:47 +03:00
|
|
|
// request.
|
|
|
|
closeUpdate, err := net.CloseChannel(ctxb, net.Alice, chanPoint, true)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to execute force channel closure: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Mine a block which should confirm the commitment transaction
|
|
|
|
// broadcast as a result of the force closure.
|
|
|
|
if _, err := net.Miner.Node.Generate(1); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to generate block: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
2016-09-18 03:34:39 +03:00
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
|
|
|
closingTxID, err := net.WaitForChannelClose(ctxt, closeUpdate)
|
2016-09-14 05:00:47 +03:00
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("error while waiting for channel close: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Currently within the codebase, the default CSV is 4 relative blocks.
|
|
|
|
// So generate exactly 4 new blocks.
|
|
|
|
// TODO(roasbeef): should check default value in config here instead,
|
|
|
|
// or make delay a param
|
|
|
|
const defaultCSV = 4
|
|
|
|
if _, err := net.Miner.Node.Generate(defaultCSV); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to mine blocks: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// At this point, the sweeping transaction should now be broadcast. So
|
|
|
|
// we fetch the node's mempool to ensure it has been properly
|
2016-09-15 22:24:52 +03:00
|
|
|
// broadcast.
|
2016-09-14 05:00:47 +03:00
|
|
|
var sweepingTXID *wire.ShaHash
|
|
|
|
var mempool []*wire.ShaHash
|
|
|
|
mempoolPoll:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-time.After(time.Second * 5):
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("sweep tx not found in mempool")
|
2016-09-14 05:00:47 +03:00
|
|
|
default:
|
|
|
|
mempool, err = net.Miner.Node.GetRawMempool()
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to fetch node's mempool: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
if len(mempool) == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
break mempoolPoll
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// There should be exactly one transaction within the mempool at this
|
|
|
|
// point.
|
|
|
|
// TODO(roasbeef): assertion may not necessarily hold with concurrent
|
|
|
|
// test executions
|
|
|
|
if len(mempool) != 1 {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("node's mempool is wrong size, expected 1 got %v",
|
2016-09-14 05:00:47 +03:00
|
|
|
len(mempool))
|
|
|
|
}
|
|
|
|
sweepingTXID = mempool[0]
|
|
|
|
|
|
|
|
// Fetch the sweep transaction, all input it's spending should be from
|
2016-09-15 22:24:52 +03:00
|
|
|
// the commitment transaction which was broadcast on-chain.
|
2016-09-14 05:00:47 +03:00
|
|
|
sweepTx, err := net.Miner.Node.GetRawTransaction(sweepingTXID)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to fetch sweep tx: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
for _, txIn := range sweepTx.MsgTx().TxIn {
|
|
|
|
if !closingTxID.IsEqual(&txIn.PreviousOutPoint.Hash) {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("sweep transaction not spending from commit "+
|
2016-09-14 05:00:47 +03:00
|
|
|
"tx %v, instead spending %v",
|
|
|
|
closingTxID, txIn.PreviousOutPoint)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, we mine an additional block which should include the sweep
|
|
|
|
// transaction as the input scripts and the sequence locks on the
|
|
|
|
// inputs should be properly met.
|
|
|
|
blockHash, err := net.Miner.Node.Generate(1)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to generate block: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
block, err := net.Miner.Node.GetBlock(blockHash[0])
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to get block: %v", err)
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
|
|
|
|
assertTxInBlock(ct, block, sweepTx.Sha())
|
2016-09-14 05:00:47 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
func testSingleHopInvoice(net *networkHarness, ct *CT) {
|
2016-09-26 20:40:58 +03:00
|
|
|
ctxb := context.Background()
|
|
|
|
timeout := time.Duration(time.Second * 5)
|
|
|
|
|
|
|
|
// Open a channel with 100k satoshis between Alice and Bob with Alice being
|
|
|
|
// the sole funder of the channel.
|
|
|
|
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
|
|
|
chanAmt := btcutil.Amount(100000)
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPoint := openChannelAndAssert(ct, net, ctxt, net.Alice, net.Bob, chanAmt)
|
2016-09-26 20:40:58 +03:00
|
|
|
|
|
|
|
// Now that the channel is open, create an invoice for Bob which
|
|
|
|
// expects a payment of 1000 satoshis from Alice paid via a particular
|
|
|
|
// pre-image.
|
|
|
|
const paymentAmt = 1000
|
|
|
|
preimage := bytes.Repeat([]byte("A"), 32)
|
|
|
|
invoice := &lnrpc.Invoice{
|
|
|
|
Memo: "testing",
|
|
|
|
RPreimage: preimage,
|
|
|
|
Value: paymentAmt,
|
|
|
|
}
|
|
|
|
invoiceResp, err := net.Bob.AddInvoice(ctxb, invoice)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to add invoice: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// With the invoice for Bob added, send a payment towards Alice paying
|
|
|
|
// to the above generated invoice.
|
|
|
|
sendStream, err := net.Alice.SendPayment(ctxb)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create alice payment stream: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
sendReq := &lnrpc.SendRequest{
|
|
|
|
PaymentHash: invoiceResp.RHash,
|
|
|
|
Dest: net.Bob.PubKey[:],
|
|
|
|
Amt: paymentAmt,
|
|
|
|
}
|
|
|
|
if err := sendStream.Send(sendReq); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to send payment: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
if _, err := sendStream.Recv(); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("error when attempting recv: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Bob's invoice should now be found and marked as settled.
|
|
|
|
// TODO(roasbeef): remove sleep after hooking into the to-be-written
|
|
|
|
// invoice settlement notification stream
|
2016-10-16 00:45:26 +03:00
|
|
|
payHash := &lnrpc.PaymentHash{
|
|
|
|
RHash: invoiceResp.RHash,
|
|
|
|
}
|
2016-09-26 20:40:58 +03:00
|
|
|
dbInvoice, err := net.Bob.LookupInvoice(ctxb, payHash)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to lookup invoice: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
if !dbInvoice.Settled {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("bob's invoice should be marked as settled: %v",
|
2016-09-26 20:40:58 +03:00
|
|
|
spew.Sdump(dbInvoice))
|
|
|
|
}
|
|
|
|
|
|
|
|
// The balances of Alice and Bob should be updated accordingly.
|
|
|
|
aliceBalance, err := net.Alice.ChannelBalance(ctxb, &lnrpc.ChannelBalanceRequest{})
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to query for alice's balance: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
bobBalance, err := net.Bob.ChannelBalance(ctxb, &lnrpc.ChannelBalanceRequest{})
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to query for bob's balance: %v", err)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if aliceBalance.Balance != int64(chanAmt-paymentAmt) {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("Alice's balance is incorrect got %v, expected %v",
|
2016-09-26 20:40:58 +03:00
|
|
|
aliceBalance, int64(chanAmt-paymentAmt))
|
|
|
|
}
|
|
|
|
if bobBalance.Balance != paymentAmt {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("Bob's balance is incorrect got %v, expected %v",
|
2016-09-26 20:40:58 +03:00
|
|
|
bobBalance, paymentAmt)
|
|
|
|
}
|
|
|
|
|
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
closeChannelAndAssert(ct, net, ctxt, net.Alice, chanPoint)
|
2016-09-26 20:40:58 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
func testMultiHopPayments(net *networkHarness, ct *CT) {
|
|
|
|
|
2016-09-26 20:41:57 +03:00
|
|
|
const chanAmt = btcutil.Amount(100000)
|
|
|
|
ctxb := context.Background()
|
|
|
|
timeout := time.Duration(time.Second * 5)
|
|
|
|
|
|
|
|
// Open a channel with 100k satoshis between Alice and Bob with Alice
|
|
|
|
// being the sole funder of the channel.
|
|
|
|
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPointAlice := openChannelAndAssert(ct, net, ctxt, net.Alice,
|
|
|
|
net.Bob, chanAmt)
|
|
|
|
|
2016-09-26 20:41:57 +03:00
|
|
|
aliceChanTXID, err := wire.NewShaHash(chanPointAlice.FundingTxid)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create sha hash: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
aliceFundPoint := wire.OutPoint{
|
|
|
|
Hash: *aliceChanTXID,
|
|
|
|
Index: chanPointAlice.OutputIndex,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a new node (Carol), load her with some funds, then establish
|
|
|
|
// a connection between Carol and Alice with a channel that has
|
|
|
|
// identical capacity to the one created above.
|
|
|
|
//
|
|
|
|
// The network topology should now look like: Carol -> Alice -> Bob
|
|
|
|
carol, err := net.NewNode(nil)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create new nodes: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
if err := net.ConnectNodes(ctxb, carol, net.Alice); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to connect carol to alice: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
err = net.SendCoins(ctxb, btcutil.SatoshiPerBitcoin, carol)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to send coins to carol: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPointCarol := openChannelAndAssert(ct, net, ctxt, carol,
|
|
|
|
net.Alice, chanAmt)
|
|
|
|
|
2016-09-26 20:41:57 +03:00
|
|
|
carolChanTXID, err := wire.NewShaHash(chanPointCarol.FundingTxid)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create sha hash: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
carolFundPoint := wire.OutPoint{
|
|
|
|
Hash: *carolChanTXID,
|
|
|
|
Index: chanPointCarol.OutputIndex,
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create 5 invoices for Bob, which expect a payment from Carol for 1k
|
|
|
|
// satoshis with a different preimage each time.
|
|
|
|
const numPayments = 5
|
|
|
|
const paymentAmt = 1000
|
|
|
|
rHashes := make([][]byte, numPayments)
|
|
|
|
for i := 0; i < numPayments; i++ {
|
|
|
|
preimage := bytes.Repeat([]byte{byte(i)}, 32)
|
|
|
|
invoice := &lnrpc.Invoice{
|
|
|
|
Memo: "testing",
|
|
|
|
RPreimage: preimage,
|
|
|
|
Value: paymentAmt,
|
|
|
|
}
|
|
|
|
resp, err := net.Bob.AddInvoice(ctxb, invoice)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to add invoice: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
rHashes[i] = resp.RHash
|
|
|
|
}
|
|
|
|
|
|
|
|
// Carol's routing table should show a path from Carol -> Alice -> Bob,
|
|
|
|
// with the two channels above recognized as the only links within the
|
|
|
|
// network.
|
2016-10-16 00:45:26 +03:00
|
|
|
time.Sleep(time.Second)
|
2016-09-26 20:41:57 +03:00
|
|
|
req := &lnrpc.ShowRoutingTableRequest{}
|
|
|
|
routingResp, err := carol.ShowRoutingTable(ctxb, req)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to query for carol's routing table: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
if len(routingResp.Channels) != 2 {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("only two channels should be seen as active in the "+
|
2016-09-26 20:41:57 +03:00
|
|
|
"network, instead %v are", len(routingResp.Channels))
|
|
|
|
}
|
|
|
|
for _, link := range routingResp.Channels {
|
|
|
|
switch {
|
|
|
|
case link.Outpoint == aliceFundPoint.String():
|
|
|
|
switch {
|
|
|
|
case link.Id1 == net.Alice.PubKeyStr &&
|
|
|
|
link.Id2 == net.Bob.PubKeyStr:
|
|
|
|
continue
|
|
|
|
case link.Id1 == net.Bob.PubKeyStr &&
|
|
|
|
link.Id2 == net.Alice.PubKeyStr:
|
|
|
|
continue
|
|
|
|
default:
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unkown link within routing "+
|
2016-09-26 20:41:57 +03:00
|
|
|
"table: %v", spew.Sdump(link))
|
|
|
|
}
|
|
|
|
case link.Outpoint == carolFundPoint.String():
|
|
|
|
switch {
|
|
|
|
case link.Id1 == net.Alice.PubKeyStr &&
|
|
|
|
link.Id2 == carol.PubKeyStr:
|
|
|
|
continue
|
|
|
|
case link.Id1 == carol.PubKeyStr &&
|
|
|
|
link.Id2 == net.Alice.PubKeyStr:
|
|
|
|
continue
|
|
|
|
default:
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unkown link within routing "+
|
2016-09-26 20:41:57 +03:00
|
|
|
"table: %v", spew.Sdump(link))
|
|
|
|
}
|
|
|
|
default:
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unkown channel %v found in routing table, "+
|
2016-09-26 20:41:57 +03:00
|
|
|
"only %v and %v should exist", link.Outpoint,
|
|
|
|
aliceFundPoint, carolFundPoint)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Using Carol as the source, pay to the 5 invoices from Bob created above.
|
|
|
|
carolPayStream, err := carol.SendPayment(ctxb)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create payment stream for carol: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Concurrently pay off all 5 of Bob's invoices. Each of the goroutines
|
|
|
|
// will unblock on the recv once the HTLC it sent has been fully
|
|
|
|
// settled.
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
for _, rHash := range rHashes {
|
|
|
|
sendReq := &lnrpc.SendRequest{
|
|
|
|
PaymentHash: rHash,
|
|
|
|
Dest: net.Bob.PubKey[:],
|
|
|
|
Amt: paymentAmt,
|
|
|
|
}
|
|
|
|
|
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
|
|
if err := carolPayStream.Send(sendReq); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to send payment: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
if _, err := carolPayStream.Recv(); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to recv pay resp: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
finClear := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
wg.Wait()
|
|
|
|
close(finClear)
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-time.After(time.Second * 10):
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("HLTC's not cleared after 10 seconds")
|
2016-09-26 20:41:57 +03:00
|
|
|
case <-finClear:
|
|
|
|
}
|
|
|
|
|
|
|
|
assertAsymmetricBalance := func(node *lightningNode,
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPoint *wire.OutPoint, localBalance,
|
|
|
|
remoteBalance int64) {
|
|
|
|
|
2016-09-26 20:41:57 +03:00
|
|
|
listReq := &lnrpc.ListChannelsRequest{}
|
|
|
|
resp, err := node.ListChannels(ctxb, listReq)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to for node's channels: %v", err)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
for _, channel := range resp.Channels {
|
|
|
|
if channel.ChannelPoint != chanPoint.String() {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if channel.LocalBalance != localBalance ||
|
|
|
|
channel.RemoteBalance != remoteBalance {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("incorrect balances: %v",
|
2016-09-26 20:41:57 +03:00
|
|
|
spew.Sdump(channel))
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("channel not found")
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// At this point all the channels within our proto network should be
|
|
|
|
// shifted by 5k satoshis in the direction of Bob, the sink within the
|
|
|
|
// payment flow generated above.
|
|
|
|
// TODO(roasbeef): remove sleep after invoice notification hooks are in
|
|
|
|
// place
|
|
|
|
time.Sleep(time.Second * 3)
|
|
|
|
const sourceBal = int64(95000)
|
|
|
|
const sinkBal = int64(5000)
|
|
|
|
assertAsymmetricBalance(carol, &carolFundPoint, sourceBal, sinkBal)
|
|
|
|
assertAsymmetricBalance(net.Alice, &carolFundPoint, sinkBal, sourceBal)
|
|
|
|
assertAsymmetricBalance(net.Alice, &aliceFundPoint, sourceBal, sinkBal)
|
|
|
|
assertAsymmetricBalance(net.Bob, &aliceFundPoint, sinkBal, sourceBal)
|
|
|
|
|
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
closeChannelAndAssert(ct, net, ctxt, net.Alice, chanPointAlice)
|
2016-09-26 20:41:57 +03:00
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
closeChannelAndAssert(ct, net, ctxt, carol, chanPointCarol)
|
2016-09-26 20:41:57 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
func testInvoiceSubscriptions(net *networkHarness, ct *CT) {
|
2016-10-16 00:45:26 +03:00
|
|
|
const chanAmt = btcutil.Amount(500000)
|
|
|
|
ctxb := context.Background()
|
|
|
|
timeout := time.Duration(time.Second * 5)
|
|
|
|
|
|
|
|
// Open a channel with 500k satoshis between Alice and Bob with Alice
|
|
|
|
// being the sole funder of the channel.
|
|
|
|
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPoint := openChannelAndAssert(ct, net, ctxt, net.Alice, net.Bob,
|
2016-10-16 00:45:26 +03:00
|
|
|
chanAmt)
|
|
|
|
|
|
|
|
// Next create a new invoice for Bob requesting 1k satoshis.
|
|
|
|
const paymentAmt = 1000
|
|
|
|
preimage := bytes.Repeat([]byte{byte(90)}, 32)
|
|
|
|
invoice := &lnrpc.Invoice{
|
|
|
|
Memo: "testing",
|
|
|
|
RPreimage: preimage,
|
|
|
|
Value: paymentAmt,
|
|
|
|
}
|
|
|
|
invoiceResp, err := net.Bob.AddInvoice(ctxb, invoice)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to add invoice: %v", err)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create a new invoice subscription client for Bob, the notification
|
|
|
|
// should be dispatched shortly below.
|
|
|
|
req := &lnrpc.InvoiceSubscription{}
|
|
|
|
bobInvoiceSubscription, err := net.Bob.SubscribeInvoices(ctxb, req)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to subscribe to bob's invoice updates: %v", err)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
updateSent := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
invoiceUpdate, err := bobInvoiceSubscription.Recv()
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to recv invoice update: %v", err)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// The invoice update should exactly match the invoice created
|
|
|
|
// above, but should now be settled.
|
|
|
|
if !invoiceUpdate.Settled {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("invoice not settled but shoudl be")
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
if !bytes.Equal(invoiceUpdate.RPreimage, invoice.RPreimage) {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("payment preimages don't match: expected %v, got %v",
|
2016-10-16 00:45:26 +03:00
|
|
|
invoice.RPreimage, invoiceUpdate.RPreimage)
|
|
|
|
}
|
|
|
|
|
|
|
|
close(updateSent)
|
|
|
|
}()
|
|
|
|
|
|
|
|
// With the assertion above set up, send a payment from Alice to Bob
|
|
|
|
// which should finalize and settle the invoice.
|
|
|
|
sendStream, err := net.Alice.SendPayment(ctxb)
|
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to create alice payment stream: %v", err)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
sendReq := &lnrpc.SendRequest{
|
|
|
|
PaymentHash: invoiceResp.RHash,
|
|
|
|
Dest: net.Bob.PubKey[:],
|
|
|
|
Amt: paymentAmt,
|
|
|
|
}
|
|
|
|
if err := sendStream.Send(sendReq); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("unable to send payment: %v", err)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
if _, err := sendStream.Recv(); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("error when attempting recv: %v", err)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-time.After(time.Second * 5):
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Errorf("update not sent after 5 seconds")
|
2016-10-16 00:45:26 +03:00
|
|
|
case <-updateSent: // Fall through on success
|
|
|
|
}
|
|
|
|
|
|
|
|
ctxt, _ = context.WithTimeout(ctxb, timeout)
|
2016-10-15 16:47:09 +03:00
|
|
|
closeChannelAndAssert(ct, net, ctxt, net.Alice, chanPoint)
|
2016-10-16 00:45:26 +03:00
|
|
|
}
|
|
|
|
|
2016-10-17 07:36:43 +03:00
|
|
|
// testBasicChannelCreation test multiple channel opening and closing.
|
2016-10-15 16:47:09 +03:00
|
|
|
func testBasicChannelCreation(net *networkHarness, ct *CT) {
|
2016-10-17 07:36:43 +03:00
|
|
|
timeout := time.Duration(time.Second * 5)
|
|
|
|
ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
|
|
|
|
|
amount := btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
|
|
|
|
|
|
num := 2
|
|
|
|
|
|
|
|
// Open the channel between Alice and Bob, asserting that the
|
|
|
|
// channel has been properly open on-chain.
|
|
|
|
chanPoints := make([]*lnrpc.ChannelPoint, num)
|
|
|
|
for i := 0; i < num; i++ {
|
2016-10-15 16:47:09 +03:00
|
|
|
chanPoints[i] = openChannelAndAssert(ct, net, ctx, net.Alice,
|
2016-10-17 07:36:43 +03:00
|
|
|
net.Bob, amount)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Close the channel between Alice and Bob, asserting that the
|
|
|
|
// channel has been properly closed on-chain.
|
|
|
|
for _, chanPoint := range chanPoints {
|
2016-10-15 16:47:09 +03:00
|
|
|
closeChannelAndAssert(ct, net, ctx, net.Alice, chanPoint)
|
2016-10-17 07:36:43 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-15 16:24:56 +03:00
|
|
|
// testMaxPendingChannels checks that error is returned from remote peer if
|
|
|
|
// max pending channel number was exceeded and that '--maxpendingchannels' flag
|
|
|
|
// exists and works properly.
|
|
|
|
func testMaxPendingChannels(net *networkHarness, ct *CT) {
|
|
|
|
maxPendingChannels := defaultMaxPendingChannels + 1
|
|
|
|
amount := btcutil.Amount(btcutil.SatoshiPerBitcoin)
|
|
|
|
|
|
|
|
timeout := time.Duration(time.Second * 10)
|
|
|
|
ctx, _ := context.WithTimeout(context.Background(), timeout)
|
|
|
|
|
|
|
|
// Create a new node (Carol) with greater number of max pending
|
|
|
|
// channels.
|
|
|
|
args := []string{
|
|
|
|
fmt.Sprintf("--maxpendingchannels=%v", maxPendingChannels),
|
|
|
|
}
|
|
|
|
|
|
|
|
carol, err := net.NewNode(args)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
ct.Errorf("unable to create new nodes: %v", err)
|
|
|
|
}
|
|
|
|
if err := net.ConnectNodes(ctx, net.Alice, carol); err != nil {
|
|
|
|
ct.Errorf("unable to connect carol to alice: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
carolBalance := btcutil.Amount(maxPendingChannels) * amount
|
|
|
|
if err := net.SendCoins(ctx, carolBalance, carol); err != nil {
|
|
|
|
ct.Errorf("unable to send coins to carol: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send open channel requests without generating new blocks thereby
|
|
|
|
// increasing pool of pending channels. Then check that we can't
|
|
|
|
// open the channel if the number of pending channels exceed
|
|
|
|
// max value.
|
|
|
|
openStreams := make([]lnrpc.Lightning_OpenChannelClient, maxPendingChannels)
|
|
|
|
for i := 0; i < maxPendingChannels; i++ {
|
|
|
|
stream, err := net.OpenChannel(ctx, net.Alice, carol, amount, 1)
|
|
|
|
if err != nil {
|
|
|
|
ct.Errorf("unable to open channel: %v", err)
|
|
|
|
}
|
|
|
|
openStreams[i] = stream
|
|
|
|
}
|
|
|
|
|
|
|
|
// Carol exhausted available amount of pending channels, next open
|
|
|
|
// channel request should cause ErrorGeneric to be sent back to Alice.
|
|
|
|
_, err = net.OpenChannel(ctx, net.Alice, carol, amount, 1)
|
|
|
|
if err == nil {
|
|
|
|
ct.Errorf("error wasn't received")
|
|
|
|
} else if grpc.Code(err) != OpenChannelFundingError {
|
|
|
|
ct.Errorf("not expected error was received : %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// For now our channels are in pending state, in order to not
|
|
|
|
// interfere with other tests we should clean up - complete opening
|
|
|
|
// of the channel and then close it.
|
|
|
|
|
|
|
|
// Mine a block, then wait for node's to notify us that the channel
|
|
|
|
// has been opened. The funding transactions should be found within the
|
|
|
|
// newly mined block.
|
|
|
|
block := mineBlocks(ct, net, 1)[0]
|
|
|
|
|
|
|
|
chanPoints := make([]*lnrpc.ChannelPoint, maxPendingChannels)
|
|
|
|
|
|
|
|
for i, stream := range openStreams {
|
|
|
|
fundingChanPoint, err := net.WaitForChannelOpen(ctx, stream)
|
|
|
|
if err != nil {
|
|
|
|
ct.Errorf("error while waiting for channel open: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
fundingTxID, err := wire.NewShaHash(fundingChanPoint.FundingTxid)
|
|
|
|
if err != nil {
|
|
|
|
ct.Errorf("unable to create sha hash: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
assertTxInBlock(ct, block, fundingTxID)
|
|
|
|
|
|
|
|
// The channel should be listed in the peer information
|
|
|
|
// returned by both peers.
|
|
|
|
chanPoint := wire.OutPoint{
|
|
|
|
Hash: *fundingTxID,
|
|
|
|
Index: fundingChanPoint.OutputIndex,
|
|
|
|
}
|
|
|
|
if err := net.AssertChannelExists(ctx, net.Alice, &chanPoint); err != nil {
|
|
|
|
ct.Errorf("unable to assert channel existence: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
chanPoints[i] = fundingChanPoint
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally close the channel between Alice and Carol, asserting that the
|
|
|
|
// channel has been properly closed on-chain.
|
|
|
|
for _, chanPoint := range chanPoints {
|
|
|
|
closeChannelAndAssert(ct, net, ctx, net.Alice, chanPoint)
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
type testCase func(net *networkHarness, ct *CT)
|
2016-10-16 00:45:26 +03:00
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
var testCases = map[string]testCase{
|
2016-10-16 00:45:26 +03:00
|
|
|
"basic funding flow": testBasicChannelFunding,
|
|
|
|
"channel force closure": testChannelForceClosure,
|
|
|
|
"channel balance": testChannelBalance,
|
|
|
|
"single hop invoice": testSingleHopInvoice,
|
2016-10-15 16:24:56 +03:00
|
|
|
"max pending channel": testMaxPendingChannels,
|
2016-10-16 00:45:26 +03:00
|
|
|
"multi-hop payments": testMultiHopPayments,
|
2016-10-15 16:24:56 +03:00
|
|
|
"multiple channel creation": testBasicChannelCreation,
|
2016-10-16 00:45:26 +03:00
|
|
|
"invoice update subscription": testInvoiceSubscriptions,
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// TestLightningNetworkDaemon performs a series of integration tests amongst a
|
2016-09-15 21:59:51 +03:00
|
|
|
// programmatically driven network of lnd nodes.
|
2016-08-30 08:07:54 +03:00
|
|
|
func TestLightningNetworkDaemon(t *testing.T) {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct := NewCT(t)
|
2016-08-30 08:07:54 +03:00
|
|
|
|
2016-08-31 05:34:13 +03:00
|
|
|
// First create the network harness to gain access to its
|
|
|
|
// 'OnTxAccepted' call back.
|
2016-10-15 16:47:09 +03:00
|
|
|
lndHarness, err := newNetworkHarness()
|
2016-08-31 05:34:13 +03:00
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Fatalf("unable to create lightning network harness: %v", err)
|
2016-08-31 05:34:13 +03:00
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
defer lndHarness.TearDownAll()
|
2016-08-31 05:34:13 +03:00
|
|
|
|
|
|
|
handlers := &btcrpcclient.NotificationHandlers{
|
2016-10-15 16:47:09 +03:00
|
|
|
OnTxAccepted: lndHarness.OnTxAccepted,
|
2016-08-31 05:34:13 +03:00
|
|
|
}
|
|
|
|
|
2016-09-15 21:59:51 +03:00
|
|
|
// First create an instance of the btcd's rpctest.Harness. This will be
|
2016-08-30 08:07:54 +03:00
|
|
|
// used to fund the wallets of the nodes within the test network and to
|
|
|
|
// drive blockchain related events within the network.
|
2016-10-15 16:47:09 +03:00
|
|
|
btcdHarness, err := rpctest.New(harnessNetParams, handlers, nil)
|
2016-08-30 08:07:54 +03:00
|
|
|
if err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Fatalf("unable to create mining node: %v", err)
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
|
|
|
defer btcdHarness.TearDown()
|
2016-10-15 16:47:09 +03:00
|
|
|
if err := btcdHarness.SetUp(true, 50); err != nil {
|
|
|
|
ct.Fatalf("unable to set up mining node: %v", err)
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
2016-08-31 05:34:13 +03:00
|
|
|
if err := btcdHarness.Node.NotifyNewTransactions(false); err != nil {
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Fatalf("unable to request transaction notifications: %v", err)
|
2016-08-31 05:34:13 +03:00
|
|
|
}
|
2016-08-30 08:07:54 +03:00
|
|
|
|
2016-08-31 05:34:13 +03:00
|
|
|
// With the btcd harness created, we can now complete the
|
2016-09-15 22:24:52 +03:00
|
|
|
// initialization of the network. args - list of lnd arguments,
|
|
|
|
// example: "--debuglevel=debug"
|
2016-09-26 20:40:58 +03:00
|
|
|
// TODO(roasbeef): create master balanced channel with all the monies?
|
2016-10-15 16:47:09 +03:00
|
|
|
if err := lndHarness.InitializeSeedNodes(btcdHarness, nil); err != nil {
|
|
|
|
ct.Fatalf("unable to initialize seed nodes: %v", err)
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
2016-10-15 16:47:09 +03:00
|
|
|
if err = lndHarness.SetUp(); err != nil {
|
|
|
|
ct.Fatalf("unable to set up test lightning network: %v", err)
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
ct.Logf("Running %v integration tests", len(testCases))
|
2016-08-30 08:07:54 +03:00
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
for name, test := range testCases {
|
|
|
|
errChan := ct.RunTest(lndHarness, test)
|
|
|
|
|
|
|
|
select {
|
|
|
|
// Receive both types of err - panic and fatal from
|
|
|
|
// one channel and raise the fatal in main goroutine.
|
|
|
|
case err := <-errChan:
|
|
|
|
if err != nil {
|
|
|
|
ct.Fatalf("Fail: (%v): exited with error: \n%v",
|
|
|
|
name, err)
|
|
|
|
}
|
|
|
|
ct.Logf("Successed: (%v)", name)
|
|
|
|
|
|
|
|
// In this case lightning node process finished with error
|
|
|
|
// status. It might be because of wrong flag, or it might
|
|
|
|
// be because of nil pointer access. Who knows!? Who knows...
|
|
|
|
// TODO(andrew.shvv) When two nodes are closing simultanisly
|
|
|
|
// it leads to panic - 'sending to the closed channel'. Fix it?
|
|
|
|
case err := <-lndHarness.lndErrorChan:
|
|
|
|
ct.Fatalf("Fail: (%v): lnd finished with error "+
|
|
|
|
"(stderr): \n%v", name, err)
|
|
|
|
}
|
2016-08-30 08:07:54 +03:00
|
|
|
}
|
|
|
|
}
|