2017-11-17 02:37:08 +03:00
|
|
|
package lntest
|
2017-06-19 16:53:52 +03:00
|
|
|
|
2017-11-03 21:52:02 +03:00
|
|
|
import (
|
2019-09-29 01:43:42 +03:00
|
|
|
"context"
|
2019-02-12 00:02:11 +03:00
|
|
|
"encoding/hex"
|
2018-03-31 08:31:37 +03:00
|
|
|
"errors"
|
2017-11-03 21:52:02 +03:00
|
|
|
"fmt"
|
2018-10-10 13:55:14 +03:00
|
|
|
"io"
|
2017-11-03 21:52:02 +03:00
|
|
|
"io/ioutil"
|
2019-04-15 17:12:59 +03:00
|
|
|
"net/http"
|
2018-10-10 13:55:14 +03:00
|
|
|
"os"
|
2020-10-26 18:36:09 +03:00
|
|
|
"path/filepath"
|
2018-03-14 12:18:32 +03:00
|
|
|
"strings"
|
2017-11-03 21:52:02 +03:00
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
2018-06-05 04:34:16 +03:00
|
|
|
"github.com/btcsuite/btcd/chaincfg"
|
|
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
|
|
"github.com/btcsuite/btcd/integration/rpctest"
|
|
|
|
"github.com/btcsuite/btcd/txscript"
|
|
|
|
"github.com/btcsuite/btcd/wire"
|
|
|
|
"github.com/btcsuite/btcutil"
|
2019-10-24 00:35:41 +03:00
|
|
|
"github.com/lightningnetwork/lnd"
|
2018-07-31 10:17:17 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnrpc"
|
2019-09-19 22:46:29 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lntest/wait"
|
2020-09-10 16:48:39 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
|
2018-08-22 10:32:42 +03:00
|
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
2019-10-24 00:35:41 +03:00
|
|
|
"google.golang.org/grpc/grpclog"
|
2017-11-03 21:52:02 +03:00
|
|
|
)
|
|
|
|
|
2019-03-28 05:00:39 +03:00
|
|
|
// DefaultCSV is the CSV delay (remotedelay) we will start our test nodes with.
|
|
|
|
const DefaultCSV = 4
|
2018-10-29 07:52:08 +03:00
|
|
|
|
2017-11-03 21:52:02 +03:00
|
|
|
// NetworkHarness is an integration testing harness for the lightning network.
|
2016-08-30 07:55:01 +03:00
|
|
|
// The harness by default is created with two active nodes on the network:
|
|
|
|
// Alice and Bob.
|
2017-11-03 21:52:02 +03:00
|
|
|
type NetworkHarness struct {
|
2016-08-30 07:55:01 +03:00
|
|
|
netParams *chaincfg.Params
|
|
|
|
|
2020-10-29 17:37:17 +03:00
|
|
|
// currentTestCase holds the name for the currently run test case.
|
|
|
|
currentTestCase string
|
|
|
|
|
2019-12-17 17:01:23 +03:00
|
|
|
// lndBinary is the full path to the lnd binary that was specifically
|
|
|
|
// compiled with all required itest flags.
|
|
|
|
lndBinary string
|
|
|
|
|
2017-11-03 21:52:02 +03:00
|
|
|
// Miner is a reference to a running full node that can be used to create
|
|
|
|
// new blocks on the network.
|
|
|
|
Miner *rpctest.Harness
|
|
|
|
|
2018-12-14 11:24:00 +03:00
|
|
|
// BackendCfg houses the information necessary to use a node as LND
|
|
|
|
// chain backend, such as rpc configuration, P2P information etc.
|
|
|
|
BackendCfg BackendConfig
|
|
|
|
|
2017-11-03 21:52:02 +03:00
|
|
|
activeNodes map[int]*HarnessNode
|
2016-08-30 07:55:01 +03:00
|
|
|
|
2017-12-21 13:32:54 +03:00
|
|
|
nodesByPub map[string]*HarnessNode
|
|
|
|
|
2016-09-10 23:14:28 +03:00
|
|
|
// Alice and Bob are the initial seeder nodes that are automatically
|
|
|
|
// created to be the initial participants of the test network.
|
2017-11-03 21:52:02 +03:00
|
|
|
Alice *HarnessNode
|
|
|
|
Bob *HarnessNode
|
2016-08-31 05:34:13 +03:00
|
|
|
|
2020-06-22 20:36:12 +03:00
|
|
|
// useEtcd is set to true if new nodes are to be created with an
|
|
|
|
// embedded etcd backend instead of just bbolt.
|
|
|
|
useEtcd bool
|
|
|
|
|
2016-10-15 16:47:09 +03:00
|
|
|
// Channel for transmitting stderr output from failed lightning node
|
|
|
|
// to main process.
|
|
|
|
lndErrorChan chan error
|
|
|
|
|
2020-09-10 16:48:39 +03:00
|
|
|
// feeService is a web service that provides external fee estimates to
|
|
|
|
// lnd.
|
|
|
|
feeService *feeService
|
|
|
|
|
2017-10-25 05:54:18 +03:00
|
|
|
quit chan struct{}
|
|
|
|
|
2017-11-17 04:31:41 +03:00
|
|
|
mtx sync.Mutex
|
2016-08-30 07:55:01 +03:00
|
|
|
}
|
|
|
|
|
2017-11-03 21:52:02 +03:00
|
|
|
// NewNetworkHarness creates a new network test harness.
|
2016-08-30 08:07:54 +03:00
|
|
|
// TODO(roasbeef): add option to use golang's build library to a binary of the
|
2018-02-07 06:11:11 +03:00
|
|
|
// current repo. This will save developers from having to manually `go install`
|
2016-09-15 21:59:51 +03:00
|
|
|
// within the repo each time before changes
|
2020-06-22 20:36:12 +03:00
|
|
|
func NewNetworkHarness(r *rpctest.Harness, b BackendConfig, lndBinary string,
|
|
|
|
useEtcd bool) (*NetworkHarness, error) {
|
2019-12-17 17:01:23 +03:00
|
|
|
|
2020-09-10 16:48:39 +03:00
|
|
|
feeService := startFeeService()
|
|
|
|
|
2017-11-17 04:31:41 +03:00
|
|
|
n := NetworkHarness{
|
2020-10-26 16:21:08 +03:00
|
|
|
activeNodes: make(map[int]*HarnessNode),
|
|
|
|
nodesByPub: make(map[string]*HarnessNode),
|
|
|
|
lndErrorChan: make(chan error),
|
|
|
|
netParams: r.ActiveNet,
|
|
|
|
Miner: r,
|
|
|
|
BackendCfg: b,
|
|
|
|
feeService: feeService,
|
|
|
|
quit: make(chan struct{}),
|
|
|
|
lndBinary: lndBinary,
|
2020-06-22 20:36:12 +03:00
|
|
|
useEtcd: useEtcd,
|
2020-10-26 16:21:08 +03:00
|
|
|
}
|
2017-11-17 04:31:41 +03:00
|
|
|
return &n, nil
|
2016-08-30 07:55:01 +03:00
|
|
|
}
|
|
|
|
|
2017-12-21 13:32:54 +03:00
|
|
|
// LookUpNodeByPub queries the set of active nodes to locate a node according
|
|
|
|
// to its public key. The second value will be true if the node was found, and
|
|
|
|
// false otherwise.
|
|
|
|
func (n *NetworkHarness) LookUpNodeByPub(pubStr string) (*HarnessNode, error) {
|
|
|
|
n.mtx.Lock()
|
|
|
|
defer n.mtx.Unlock()
|
|
|
|
|
|
|
|
node, ok := n.nodesByPub[pubStr]
|
|
|
|
if !ok {
|
|
|
|
return nil, fmt.Errorf("unable to find node")
|
|
|
|
}
|
|
|
|
|
|
|
|
return node, nil
|
|
|
|
}
|
|
|
|
|
2016-10-24 05:00:09 +03:00
|
|
|
// ProcessErrors returns a channel used for reporting any fatal process errors.
|
|
|
|
// If any of the active nodes within the harness' test network incur a fatal
|
|
|
|
// error, that error is sent over this channel.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) ProcessErrors() <-chan error {
|
2016-10-24 05:00:09 +03:00
|
|
|
return n.lndErrorChan
|
|
|
|
}
|
|
|
|
|
2016-08-30 07:55:01 +03:00
|
|
|
// fakeLogger is a fake grpclog.Logger implementation. This is used to stop
|
|
|
|
// grpc's logger from printing directly to stdout.
|
|
|
|
type fakeLogger struct{}
|
|
|
|
|
|
|
|
func (f *fakeLogger) Fatal(args ...interface{}) {}
|
|
|
|
func (f *fakeLogger) Fatalf(format string, args ...interface{}) {}
|
|
|
|
func (f *fakeLogger) Fatalln(args ...interface{}) {}
|
|
|
|
func (f *fakeLogger) Print(args ...interface{}) {}
|
|
|
|
func (f *fakeLogger) Printf(format string, args ...interface{}) {}
|
|
|
|
func (f *fakeLogger) Println(args ...interface{}) {}
|
|
|
|
|
|
|
|
// SetUp starts the initial seeder nodes within the test harness. The initial
|
|
|
|
// node's wallets will be funded wallets with ten 1 BTC outputs each. Finally
|
|
|
|
// rpc clients capable of communicating with the initial seeder nodes are
|
2017-11-17 04:31:41 +03:00
|
|
|
// created. Nodes are initialized with the given extra command line flags, which
|
|
|
|
// should be formatted properly - "--arg=value".
|
2020-10-29 17:37:17 +03:00
|
|
|
func (n *NetworkHarness) SetUp(testCase string, lndArgs []string) error {
|
2016-08-30 07:55:01 +03:00
|
|
|
// Swap out grpc's default logger with out fake logger which drops the
|
|
|
|
// statements on the floor.
|
|
|
|
grpclog.SetLogger(&fakeLogger{})
|
2020-10-29 17:37:17 +03:00
|
|
|
n.currentTestCase = testCase
|
2017-10-25 05:35:54 +03:00
|
|
|
|
2016-08-30 07:55:01 +03:00
|
|
|
// Start the initial seeder nodes within the test network, then connect
|
|
|
|
// their respective RPC clients.
|
2016-08-31 02:44:47 +03:00
|
|
|
var wg sync.WaitGroup
|
|
|
|
errChan := make(chan error, 2)
|
|
|
|
wg.Add(2)
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
2018-04-27 11:42:04 +03:00
|
|
|
node, err := n.NewNode("Alice", lndArgs)
|
2017-11-17 04:31:41 +03:00
|
|
|
if err != nil {
|
2016-08-31 02:44:47 +03:00
|
|
|
errChan <- err
|
2017-11-17 04:31:41 +03:00
|
|
|
return
|
2016-08-31 02:44:47 +03:00
|
|
|
}
|
2017-11-17 04:31:41 +03:00
|
|
|
n.Alice = node
|
2016-08-31 02:44:47 +03:00
|
|
|
}()
|
|
|
|
go func() {
|
|
|
|
defer wg.Done()
|
2018-04-27 11:42:04 +03:00
|
|
|
node, err := n.NewNode("Bob", lndArgs)
|
2017-11-17 04:31:41 +03:00
|
|
|
if err != nil {
|
2016-08-31 02:44:47 +03:00
|
|
|
errChan <- err
|
2017-11-17 04:31:41 +03:00
|
|
|
return
|
2016-08-31 02:44:47 +03:00
|
|
|
}
|
2017-11-17 04:31:41 +03:00
|
|
|
n.Bob = node
|
2016-08-31 02:44:47 +03:00
|
|
|
}()
|
|
|
|
wg.Wait()
|
|
|
|
select {
|
|
|
|
case err := <-errChan:
|
2016-08-30 07:55:01 +03:00
|
|
|
return err
|
2016-08-31 02:44:47 +03:00
|
|
|
default:
|
2016-08-30 07:55:01 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Load up the wallets of the seeder nodes with 10 outputs of 1 BTC
|
|
|
|
// each.
|
|
|
|
ctxb := context.Background()
|
2017-02-10 02:28:32 +03:00
|
|
|
addrReq := &lnrpc.NewAddressRequest{
|
2018-09-27 16:49:44 +03:00
|
|
|
Type: lnrpc.AddressType_WITNESS_PUBKEY_HASH,
|
2017-02-10 02:28:32 +03:00
|
|
|
}
|
2016-09-10 23:14:28 +03:00
|
|
|
clients := []lnrpc.LightningClient{n.Alice, n.Bob}
|
2016-08-30 07:55:01 +03:00
|
|
|
for _, client := range clients {
|
|
|
|
for i := 0; i < 10; i++ {
|
|
|
|
resp, err := client.NewAddress(ctxb, addrReq)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
addr, err := btcutil.DecodeAddress(resp.Address, n.netParams)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
addrScript, err := txscript.PayToAddrScript(addr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
output := &wire.TxOut{
|
|
|
|
PkScript: addrScript,
|
|
|
|
Value: btcutil.SatoshiPerBitcoin,
|
|
|
|
}
|
2018-07-28 04:20:58 +03:00
|
|
|
_, err = n.Miner.SendOutputs([]*wire.TxOut{output}, 7500)
|
|
|
|
if err != nil {
|
2016-08-30 07:55:01 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We generate several blocks in order to give the outputs created
|
|
|
|
// above a good number of confirmations.
|
|
|
|
if _, err := n.Miner.Node.Generate(10); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, make a connection between both of the nodes.
|
2016-09-26 20:31:07 +03:00
|
|
|
if err := n.ConnectNodes(ctxb, n.Alice, n.Bob); err != nil {
|
2016-08-30 07:55:01 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-08-31 02:44:47 +03:00
|
|
|
// Now block until both wallets have fully synced up.
|
2017-07-05 01:52:58 +03:00
|
|
|
expectedBalance := int64(btcutil.SatoshiPerBitcoin * 10)
|
2016-08-31 02:44:47 +03:00
|
|
|
balReq := &lnrpc.WalletBalanceRequest{}
|
2020-04-14 19:17:28 +03:00
|
|
|
balanceTicker := time.NewTicker(time.Millisecond * 50)
|
|
|
|
defer balanceTicker.Stop()
|
2017-08-11 00:05:04 +03:00
|
|
|
balanceTimeout := time.After(time.Second * 30)
|
2016-08-31 02:44:47 +03:00
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
2020-04-14 19:17:28 +03:00
|
|
|
case <-balanceTicker.C:
|
2016-09-10 23:14:28 +03:00
|
|
|
aliceResp, err := n.Alice.WalletBalance(ctxb, balReq)
|
2016-08-31 02:44:47 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-09-10 23:14:28 +03:00
|
|
|
bobResp, err := n.Bob.WalletBalance(ctxb, balReq)
|
2016-08-31 02:44:47 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-11-26 16:17:57 +03:00
|
|
|
if aliceResp.ConfirmedBalance == expectedBalance &&
|
|
|
|
bobResp.ConfirmedBalance == expectedBalance {
|
2016-08-31 02:44:47 +03:00
|
|
|
break out
|
|
|
|
}
|
2017-08-11 00:05:04 +03:00
|
|
|
case <-balanceTimeout:
|
2016-09-18 03:34:39 +03:00
|
|
|
return fmt.Errorf("balances not synced after deadline")
|
2016-08-31 02:44:47 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-30 07:55:01 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-10-29 17:37:17 +03:00
|
|
|
// TearDown tears down all active nodes within the test lightning network.
|
|
|
|
func (n *NetworkHarness) TearDown() error {
|
2016-08-31 21:59:08 +03:00
|
|
|
for _, node := range n.activeNodes {
|
2017-11-04 00:40:57 +03:00
|
|
|
if err := n.ShutdownNode(node); err != nil {
|
2016-08-31 21:59:08 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-29 17:37:17 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Stop stops the test harness.
|
|
|
|
func (n *NetworkHarness) Stop() {
|
2017-10-25 05:35:54 +03:00
|
|
|
close(n.lndErrorChan)
|
2017-10-25 05:54:18 +03:00
|
|
|
close(n.quit)
|
|
|
|
|
2020-09-10 16:48:39 +03:00
|
|
|
n.feeService.stop()
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
|
2018-02-07 06:11:11 +03:00
|
|
|
// NewNode fully initializes a returns a new HarnessNode bound to the
|
2016-09-26 20:30:24 +03:00
|
|
|
// current instance of the network harness. The created node is running, but
|
|
|
|
// not yet connected to other nodes within the network.
|
2018-04-27 11:42:04 +03:00
|
|
|
func (n *NetworkHarness) NewNode(name string, extraArgs []string) (*HarnessNode, error) {
|
2019-03-11 02:31:43 +03:00
|
|
|
return n.newNode(name, extraArgs, false, nil)
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewNodeWithSeed fully initializes a new HarnessNode after creating a fresh
|
|
|
|
// aezeed. The provided password is used as both the aezeed password and the
|
|
|
|
// wallet password. The generated mnemonic is returned along with the
|
|
|
|
// initialized harness node.
|
2018-04-27 11:42:04 +03:00
|
|
|
func (n *NetworkHarness) NewNodeWithSeed(name string, extraArgs []string,
|
2020-10-06 18:23:40 +03:00
|
|
|
password []byte, statelessInit bool) (*HarnessNode, []string, []byte,
|
|
|
|
error) {
|
2018-04-03 02:57:04 +03:00
|
|
|
|
2019-03-11 02:31:43 +03:00
|
|
|
node, err := n.newNode(name, extraArgs, true, password)
|
2018-04-03 02:57:04 +03:00
|
|
|
if err != nil {
|
2020-10-06 18:23:40 +03:00
|
|
|
return nil, nil, nil, err
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
timeout := time.Duration(time.Second * 15)
|
|
|
|
ctxb := context.Background()
|
|
|
|
|
|
|
|
// Create a request to generate a new aezeed. The new seed will have the
|
|
|
|
// same password as the internal wallet.
|
|
|
|
genSeedReq := &lnrpc.GenSeedRequest{
|
|
|
|
AezeedPassphrase: password,
|
|
|
|
}
|
|
|
|
|
|
|
|
ctxt, _ := context.WithTimeout(ctxb, timeout)
|
|
|
|
genSeedResp, err := node.GenSeed(ctxt, genSeedReq)
|
|
|
|
if err != nil {
|
2020-10-06 18:23:40 +03:00
|
|
|
return nil, nil, nil, err
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// With the seed created, construct the init request to the node,
|
|
|
|
// including the newly generated seed.
|
|
|
|
initReq := &lnrpc.InitWalletRequest{
|
|
|
|
WalletPassword: password,
|
|
|
|
CipherSeedMnemonic: genSeedResp.CipherSeedMnemonic,
|
|
|
|
AezeedPassphrase: password,
|
2020-10-06 18:23:40 +03:00
|
|
|
StatelessInit: statelessInit,
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Pass the init request via rpc to finish unlocking the node. This will
|
|
|
|
// also initialize the macaroon-authenticated LightningClient.
|
2020-10-06 18:23:40 +03:00
|
|
|
response, err := node.Init(ctxb, initReq)
|
2018-04-03 02:57:04 +03:00
|
|
|
if err != nil {
|
2020-10-06 18:23:40 +03:00
|
|
|
return nil, nil, nil, err
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// With the node started, we can now record its public key within the
|
|
|
|
// global mapping.
|
|
|
|
n.RegisterNode(node)
|
|
|
|
|
2020-10-06 18:23:40 +03:00
|
|
|
// In stateless initialization mode we get a macaroon back that we have
|
|
|
|
// to return to the test, otherwise gRPC calls won't be possible since
|
|
|
|
// there are no macaroon files created in that mode.
|
|
|
|
// In stateful init the admin macaroon will just be nil.
|
|
|
|
return node, genSeedResp.CipherSeedMnemonic, response.AdminMacaroon, nil
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// RestoreNodeWithSeed fully initializes a HarnessNode using a chosen mnemonic,
|
2019-03-12 02:18:10 +03:00
|
|
|
// password, recovery window, and optionally a set of static channel backups.
|
|
|
|
// After providing the initialization request to unlock the node, this method
|
|
|
|
// will finish initializing the LightningClient such that the HarnessNode can
|
|
|
|
// be used for regular rpc operations.
|
2018-04-27 11:42:04 +03:00
|
|
|
func (n *NetworkHarness) RestoreNodeWithSeed(name string, extraArgs []string,
|
2019-03-12 02:18:10 +03:00
|
|
|
password []byte, mnemonic []string, recoveryWindow int32,
|
|
|
|
chanBackups *lnrpc.ChanBackupSnapshot) (*HarnessNode, error) {
|
2018-04-03 02:57:04 +03:00
|
|
|
|
2019-03-11 02:31:43 +03:00
|
|
|
node, err := n.newNode(name, extraArgs, true, password)
|
2018-04-03 02:57:04 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
initReq := &lnrpc.InitWalletRequest{
|
|
|
|
WalletPassword: password,
|
|
|
|
CipherSeedMnemonic: mnemonic,
|
|
|
|
AezeedPassphrase: password,
|
|
|
|
RecoveryWindow: recoveryWindow,
|
2019-03-12 02:18:10 +03:00
|
|
|
ChannelBackups: chanBackups,
|
2018-04-03 02:57:04 +03:00
|
|
|
}
|
|
|
|
|
2020-10-06 18:23:40 +03:00
|
|
|
_, err = node.Init(context.Background(), initReq)
|
2018-04-03 02:57:04 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// With the node started, we can now record its public key within the
|
|
|
|
// global mapping.
|
|
|
|
n.RegisterNode(node)
|
|
|
|
|
|
|
|
return node, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// newNode initializes a new HarnessNode, supporting the ability to initialize a
|
|
|
|
// wallet with or without a seed. If hasSeed is false, the returned harness node
|
|
|
|
// can be used immediately. Otherwise, the node will require an additional
|
|
|
|
// initialization phase where the wallet is either created or restored.
|
2020-10-29 17:37:17 +03:00
|
|
|
func (n *NetworkHarness) newNode(name string, extraArgs []string, hasSeed bool,
|
|
|
|
password []byte) (*HarnessNode, error) {
|
2019-03-11 02:31:43 +03:00
|
|
|
|
2019-12-17 12:48:17 +03:00
|
|
|
node, err := newNode(NodeConfig{
|
2020-10-29 17:37:17 +03:00
|
|
|
Name: name,
|
|
|
|
LogFilenamePrefix: n.currentTestCase,
|
|
|
|
HasSeed: hasSeed,
|
|
|
|
Password: password,
|
|
|
|
BackendCfg: n.BackendCfg,
|
|
|
|
NetParams: n.netParams,
|
|
|
|
ExtraArgs: extraArgs,
|
|
|
|
FeeURL: n.feeService.url,
|
2020-06-22 20:36:12 +03:00
|
|
|
Etcd: n.useEtcd,
|
2017-11-04 00:06:07 +03:00
|
|
|
})
|
2016-09-26 20:30:24 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2017-10-25 05:39:50 +03:00
|
|
|
// Put node in activeNodes to ensure Shutdown is called even if Start
|
|
|
|
// returns an error.
|
2017-11-17 04:31:41 +03:00
|
|
|
n.mtx.Lock()
|
2017-11-03 21:52:02 +03:00
|
|
|
n.activeNodes[node.NodeID] = node
|
2017-11-17 04:31:41 +03:00
|
|
|
n.mtx.Unlock()
|
2017-10-25 05:39:50 +03:00
|
|
|
|
2019-12-17 17:01:23 +03:00
|
|
|
if err := node.start(n.lndBinary, n.lndErrorChan); err != nil {
|
2016-09-26 20:30:24 +03:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2018-04-03 02:57:04 +03:00
|
|
|
// If this node is to have a seed, it will need to be unlocked or
|
|
|
|
// initialized via rpc. Delay registering it with the network until it
|
|
|
|
// can be driven via an unlocked rpc connection.
|
2019-12-17 12:48:17 +03:00
|
|
|
if node.Cfg.HasSeed {
|
2018-04-03 02:57:04 +03:00
|
|
|
return node, nil
|
|
|
|
}
|
|
|
|
|
2017-12-21 13:32:54 +03:00
|
|
|
// With the node started, we can now record its public key within the
|
|
|
|
// global mapping.
|
2018-04-03 02:57:04 +03:00
|
|
|
n.RegisterNode(node)
|
|
|
|
|
|
|
|
return node, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// RegisterNode records a new HarnessNode in the NetworkHarnesses map of known
|
|
|
|
// nodes. This method should only be called with nodes that have successfully
|
|
|
|
// retrieved their public keys via FetchNodeInfo.
|
|
|
|
func (n *NetworkHarness) RegisterNode(node *HarnessNode) {
|
2017-12-21 13:32:54 +03:00
|
|
|
n.mtx.Lock()
|
|
|
|
n.nodesByPub[node.PubKeyStr] = node
|
|
|
|
n.mtx.Unlock()
|
2016-09-26 20:30:24 +03:00
|
|
|
}
|
2016-09-26 20:31:07 +03:00
|
|
|
|
2018-10-29 07:52:09 +03:00
|
|
|
func (n *NetworkHarness) connect(ctx context.Context,
|
|
|
|
req *lnrpc.ConnectPeerRequest, a *HarnessNode) error {
|
|
|
|
|
|
|
|
syncTimeout := time.After(15 * time.Second)
|
|
|
|
tryconnect:
|
|
|
|
if _, err := a.ConnectPeer(ctx, req); err != nil {
|
|
|
|
// If the chain backend is still syncing, retry.
|
2020-07-27 15:15:36 +03:00
|
|
|
if strings.Contains(err.Error(), lnd.ErrServerNotActive.Error()) ||
|
|
|
|
strings.Contains(err.Error(), "i/o timeout") {
|
|
|
|
|
2018-10-29 07:52:09 +03:00
|
|
|
select {
|
|
|
|
case <-time.After(100 * time.Millisecond):
|
|
|
|
goto tryconnect
|
|
|
|
case <-syncTimeout:
|
|
|
|
return fmt.Errorf("chain backend did not " +
|
|
|
|
"finish syncing")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-14 12:18:32 +03:00
|
|
|
// EnsureConnected will try to connect to two nodes, returning no error if they
|
|
|
|
// are already connected. If the nodes were not connected previously, this will
|
|
|
|
// behave the same as ConnectNodes. If a pending connection request has already
|
|
|
|
// been made, the method will block until the two nodes appear in each other's
|
|
|
|
// peers list, or until the 15s timeout expires.
|
|
|
|
func (n *NetworkHarness) EnsureConnected(ctx context.Context, a, b *HarnessNode) error {
|
2018-03-31 08:31:37 +03:00
|
|
|
// errConnectionRequested is used to signal that a connection was
|
|
|
|
// requested successfully, which is distinct from already being
|
|
|
|
// connected to the peer.
|
|
|
|
errConnectionRequested := errors.New("connection request in progress")
|
|
|
|
|
|
|
|
tryConnect := func(a, b *HarnessNode) error {
|
|
|
|
ctxt, _ := context.WithTimeout(ctx, 15*time.Second)
|
|
|
|
bInfo, err := b.GetInfo(ctxt, &lnrpc.GetInfoRequest{})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-03-14 12:18:32 +03:00
|
|
|
|
2018-03-31 08:31:37 +03:00
|
|
|
req := &lnrpc.ConnectPeerRequest{
|
|
|
|
Addr: &lnrpc.LightningAddress{
|
|
|
|
Pubkey: bInfo.IdentityPubkey,
|
2019-12-17 12:48:17 +03:00
|
|
|
Host: b.Cfg.P2PAddr(),
|
2018-03-31 08:31:37 +03:00
|
|
|
},
|
|
|
|
}
|
2018-03-14 12:18:32 +03:00
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
var predErr error
|
|
|
|
err = wait.Predicate(func() bool {
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
|
|
|
|
defer cancel()
|
|
|
|
|
|
|
|
err := n.connect(ctx, req, a)
|
|
|
|
switch {
|
|
|
|
// Request was successful, wait for both to display the
|
|
|
|
// connection.
|
|
|
|
case err == nil:
|
|
|
|
predErr = errConnectionRequested
|
|
|
|
return true
|
2018-03-14 12:18:32 +03:00
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
// If the two are already connected, we return early
|
|
|
|
// with no error.
|
|
|
|
case strings.Contains(
|
|
|
|
err.Error(), "already connected to peer",
|
|
|
|
):
|
|
|
|
predErr = nil
|
|
|
|
return true
|
2018-03-14 12:18:32 +03:00
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
default:
|
|
|
|
predErr = err
|
|
|
|
return false
|
|
|
|
}
|
2018-03-14 12:18:32 +03:00
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
}, DefaultTimeout)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("connection not succeeded within 15 "+
|
|
|
|
"seconds: %v", predErr)
|
2018-03-31 08:31:37 +03:00
|
|
|
}
|
2019-09-25 13:43:09 +03:00
|
|
|
|
|
|
|
return predErr
|
2018-03-31 08:31:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
aErr := tryConnect(a, b)
|
|
|
|
bErr := tryConnect(b, a)
|
|
|
|
switch {
|
2019-09-25 13:43:09 +03:00
|
|
|
// If both reported already being connected to each other, we can exit
|
|
|
|
// early.
|
2018-03-31 08:31:37 +03:00
|
|
|
case aErr == nil && bErr == nil:
|
2018-03-14 12:18:32 +03:00
|
|
|
return nil
|
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
// Return any critical errors returned by either alice.
|
2019-02-25 19:03:56 +03:00
|
|
|
case aErr != nil && aErr != errConnectionRequested:
|
2018-03-31 08:31:37 +03:00
|
|
|
return aErr
|
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
// Return any critical errors returned by either bob.
|
2019-02-25 19:03:56 +03:00
|
|
|
case bErr != nil && bErr != errConnectionRequested:
|
2018-03-31 08:31:37 +03:00
|
|
|
return bErr
|
|
|
|
|
2019-09-25 13:43:09 +03:00
|
|
|
// Otherwise one or both requested a connection, so we wait for the
|
|
|
|
// peers lists to reflect the connection.
|
2018-03-14 12:18:32 +03:00
|
|
|
default:
|
|
|
|
}
|
|
|
|
|
2018-03-31 08:31:37 +03:00
|
|
|
findSelfInPeerList := func(a, b *HarnessNode) bool {
|
2018-03-14 12:18:32 +03:00
|
|
|
// If node B is seen in the ListPeers response from node A,
|
|
|
|
// then we can exit early as the connection has been fully
|
|
|
|
// established.
|
2018-03-31 08:31:37 +03:00
|
|
|
ctxt, _ := context.WithTimeout(ctx, 15*time.Second)
|
|
|
|
resp, err := b.ListPeers(ctxt, &lnrpc.ListPeersRequest{})
|
2018-03-14 12:18:32 +03:00
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, peer := range resp.Peers {
|
2018-03-31 08:31:37 +03:00
|
|
|
if peer.PubKey == a.PubKeyStr {
|
2018-03-14 12:18:32 +03:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
2018-03-31 08:31:37 +03:00
|
|
|
}
|
|
|
|
|
2019-09-19 22:46:29 +03:00
|
|
|
err := wait.Predicate(func() bool {
|
2018-03-31 08:31:37 +03:00
|
|
|
return findSelfInPeerList(a, b) && findSelfInPeerList(b, a)
|
2018-03-14 12:18:32 +03:00
|
|
|
}, time.Second*15)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("peers not connected within 15 seconds")
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-09-26 20:31:07 +03:00
|
|
|
// ConnectNodes establishes an encrypted+authenticated p2p connection from node
|
2017-04-14 01:11:20 +03:00
|
|
|
// a towards node b. The function will return a non-nil error if the connection
|
|
|
|
// was unable to be established.
|
|
|
|
//
|
|
|
|
// NOTE: This function may block for up to 15-seconds as it will not return
|
|
|
|
// until the new connection is detected as being known to both nodes.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) ConnectNodes(ctx context.Context, a, b *HarnessNode) error {
|
2016-09-26 20:31:07 +03:00
|
|
|
bobInfo, err := b.GetInfo(ctx, &lnrpc.GetInfoRequest{})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
req := &lnrpc.ConnectPeerRequest{
|
|
|
|
Addr: &lnrpc.LightningAddress{
|
2016-10-28 05:43:31 +03:00
|
|
|
Pubkey: bobInfo.IdentityPubkey,
|
2019-12-17 12:48:17 +03:00
|
|
|
Host: b.Cfg.P2PAddr(),
|
2016-09-26 20:31:07 +03:00
|
|
|
},
|
|
|
|
}
|
2018-10-29 07:52:09 +03:00
|
|
|
|
|
|
|
if err := n.connect(ctx, req, a); err != nil {
|
2017-04-14 01:11:20 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-09-19 22:46:29 +03:00
|
|
|
err = wait.Predicate(func() bool {
|
2017-04-14 01:11:20 +03:00
|
|
|
// If node B is seen in the ListPeers response from node A,
|
|
|
|
// then we can exit early as the connection has been fully
|
|
|
|
// established.
|
|
|
|
resp, err := a.ListPeers(ctx, &lnrpc.ListPeersRequest{})
|
|
|
|
if err != nil {
|
2017-12-21 13:44:15 +03:00
|
|
|
return false
|
2017-04-14 01:11:20 +03:00
|
|
|
}
|
2017-12-21 13:44:15 +03:00
|
|
|
|
2017-04-14 01:11:20 +03:00
|
|
|
for _, peer := range resp.Peers {
|
|
|
|
if peer.PubKey == b.PubKeyStr {
|
2017-12-21 13:44:15 +03:00
|
|
|
return true
|
2017-04-14 01:11:20 +03:00
|
|
|
}
|
|
|
|
}
|
2017-12-21 13:44:15 +03:00
|
|
|
|
|
|
|
return false
|
|
|
|
}, time.Second*15)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("peers not connected within 15 seconds")
|
2017-04-14 01:11:20 +03:00
|
|
|
}
|
2017-12-21 13:44:15 +03:00
|
|
|
|
|
|
|
return nil
|
2016-09-26 20:31:07 +03:00
|
|
|
}
|
|
|
|
|
2017-05-05 10:00:39 +03:00
|
|
|
// DisconnectNodes disconnects node a from node b by sending RPC message
|
|
|
|
// from a node to b node
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) DisconnectNodes(ctx context.Context, a, b *HarnessNode) error {
|
2017-05-05 10:00:39 +03:00
|
|
|
bobInfo, err := b.GetInfo(ctx, &lnrpc.GetInfoRequest{})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
req := &lnrpc.DisconnectPeerRequest{
|
|
|
|
PubKey: bobInfo.IdentityPubkey,
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := a.DisconnectPeer(ctx, req); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-08-09 11:03:15 +03:00
|
|
|
// RestartNode attempts to restart a lightning node by shutting it down
|
2016-11-15 02:49:02 +03:00
|
|
|
// cleanly, then restarting the process. This function is fully blocking. Upon
|
|
|
|
// restart, the RPC connection to the node will be re-attempted, continuing iff
|
2016-11-22 06:08:44 +03:00
|
|
|
// the connection attempt is successful. If the callback parameter is non-nil,
|
|
|
|
// then the function will be executed after the node shuts down, but *before*
|
|
|
|
// the process has been started up again.
|
2016-11-15 02:49:02 +03:00
|
|
|
//
|
|
|
|
// This method can be useful when testing edge cases such as a node broadcast
|
|
|
|
// and invalidated prior state, or persistent state recovery, simulating node
|
2019-03-12 02:18:10 +03:00
|
|
|
// crashes, etc. Additionally, each time the node is restarted, the caller can
|
|
|
|
// pass a set of SCBs to pass in via the Unlock method allowing them to restore
|
|
|
|
// channels during restart.
|
|
|
|
func (n *NetworkHarness) RestartNode(node *HarnessNode, callback func() error,
|
|
|
|
chanBackups ...*lnrpc.ChanBackupSnapshot) error {
|
2019-03-11 02:32:44 +03:00
|
|
|
|
2020-10-06 18:23:40 +03:00
|
|
|
err := n.RestartNodeNoUnlock(node, callback)
|
|
|
|
if err != nil {
|
2019-03-11 02:32:44 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the node doesn't have a password set, then we can exit here as we
|
|
|
|
// don't need to unlock it.
|
2019-12-17 12:48:17 +03:00
|
|
|
if len(node.Cfg.Password) == 0 {
|
2019-03-11 02:32:44 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we'll unlock the wallet, then complete the final steps
|
|
|
|
// for the node initialization process.
|
2019-03-12 02:18:10 +03:00
|
|
|
unlockReq := &lnrpc.UnlockWalletRequest{
|
2019-12-17 12:48:17 +03:00
|
|
|
WalletPassword: node.Cfg.Password,
|
2019-03-12 02:18:10 +03:00
|
|
|
}
|
|
|
|
if len(chanBackups) != 0 {
|
|
|
|
unlockReq.ChannelBackups = chanBackups[0]
|
|
|
|
unlockReq.RecoveryWindow = 1000
|
|
|
|
}
|
|
|
|
|
|
|
|
return node.Unlock(context.Background(), unlockReq)
|
2016-11-15 02:49:02 +03:00
|
|
|
}
|
|
|
|
|
2020-10-06 18:23:40 +03:00
|
|
|
// RestartNodeNoUnlock attempts to restart a lightning node by shutting it down
|
|
|
|
// cleanly, then restarting the process. In case the node was setup with a seed,
|
|
|
|
// it will be left in the unlocked state. This function is fully blocking. If
|
|
|
|
// the callback parameter is non-nil, then the function will be executed after
|
|
|
|
// the node shuts down, but *before* the process has been started up again.
|
|
|
|
func (n *NetworkHarness) RestartNodeNoUnlock(node *HarnessNode,
|
|
|
|
callback func() error) error {
|
|
|
|
|
|
|
|
if err := node.stop(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if callback != nil {
|
|
|
|
if err := callback(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return node.start(n.lndBinary, n.lndErrorChan)
|
|
|
|
}
|
|
|
|
|
2018-08-09 11:03:15 +03:00
|
|
|
// SuspendNode stops the given node and returns a callback that can be used to
|
|
|
|
// start it again.
|
|
|
|
func (n *NetworkHarness) SuspendNode(node *HarnessNode) (func() error, error) {
|
|
|
|
if err := node.stop(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
restart := func() error {
|
2019-12-17 17:01:23 +03:00
|
|
|
return node.start(n.lndBinary, n.lndErrorChan)
|
2018-08-09 11:03:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return restart, nil
|
|
|
|
}
|
|
|
|
|
2017-11-04 00:40:57 +03:00
|
|
|
// ShutdownNode stops an active lnd process and returns when the process has
|
|
|
|
// exited and any temporary directories have been cleaned up.
|
|
|
|
func (n *NetworkHarness) ShutdownNode(node *HarnessNode) error {
|
|
|
|
if err := node.shutdown(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
delete(n.activeNodes, node.NodeID)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-06-09 06:37:04 +03:00
|
|
|
// StopNode stops the target node, but doesn't yet clean up its directories.
|
|
|
|
// This can be used to temporarily bring a node down during a test, to be later
|
|
|
|
// started up again.
|
|
|
|
func (n *NetworkHarness) StopNode(node *HarnessNode) error {
|
|
|
|
return node.stop()
|
|
|
|
}
|
|
|
|
|
2019-04-15 17:12:59 +03:00
|
|
|
// SaveProfilesPages hits profiles pages of all active nodes and writes it to
|
|
|
|
// disk using a similar naming scheme as to the regular set of logs.
|
|
|
|
func (n *NetworkHarness) SaveProfilesPages() {
|
2019-04-15 17:28:01 +03:00
|
|
|
// Only write gorutine dumps if flag is active.
|
|
|
|
if !(*goroutineDump) {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-04-15 17:12:59 +03:00
|
|
|
for _, node := range n.activeNodes {
|
|
|
|
if err := saveProfilesPage(node); err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
fmt.Printf("Error: %v\n", err)
|
2019-04-15 17:12:59 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// saveProfilesPage saves the profiles page for the given node to file.
|
|
|
|
func saveProfilesPage(node *HarnessNode) error {
|
|
|
|
resp, err := http.Get(
|
|
|
|
fmt.Sprintf(
|
|
|
|
"http://localhost:%d/debug/pprof/goroutine?debug=1",
|
2019-12-17 12:48:17 +03:00
|
|
|
node.Cfg.ProfilePort,
|
2019-04-15 17:12:59 +03:00
|
|
|
),
|
|
|
|
)
|
|
|
|
if err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return fmt.Errorf("failed to get profile page "+
|
|
|
|
"(node_id=%d, name=%s): %v",
|
2019-12-17 12:48:17 +03:00
|
|
|
node.NodeID, node.Cfg.Name, err)
|
2019-04-15 17:12:59 +03:00
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
|
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
|
|
if err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return fmt.Errorf("failed to read profile page "+
|
|
|
|
"(node_id=%d, name=%s): %v",
|
2019-12-17 12:48:17 +03:00
|
|
|
node.NodeID, node.Cfg.Name, err)
|
2019-04-15 17:12:59 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fileName := fmt.Sprintf(
|
2019-12-17 12:48:17 +03:00
|
|
|
"pprof-%d-%s-%s.log", node.NodeID, node.Cfg.Name,
|
2019-04-15 17:12:59 +03:00
|
|
|
hex.EncodeToString(node.PubKey[:logPubKeyBytes]),
|
|
|
|
)
|
|
|
|
|
|
|
|
logFile, err := os.Create(fileName)
|
|
|
|
if err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return fmt.Errorf("failed to create file for profile page "+
|
|
|
|
"(node_id=%d, name=%s): %v",
|
2019-12-17 12:48:17 +03:00
|
|
|
node.NodeID, node.Cfg.Name, err)
|
2019-04-15 17:12:59 +03:00
|
|
|
}
|
|
|
|
defer logFile.Close()
|
|
|
|
|
|
|
|
_, err = logFile.Write(body)
|
|
|
|
if err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return fmt.Errorf("failed to save profile page "+
|
|
|
|
"(node_id=%d, name=%s): %v",
|
2019-12-17 12:48:17 +03:00
|
|
|
node.NodeID, node.Cfg.Name, err)
|
2019-04-15 17:12:59 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-10-26 16:21:08 +03:00
|
|
|
// WaitForTxInMempool blocks until the target txid is seen in the mempool. If
|
2016-09-18 03:34:39 +03:00
|
|
|
// the transaction isn't seen within the network before the passed timeout,
|
2016-11-22 06:08:44 +03:00
|
|
|
// then an error is returned.
|
2020-10-26 16:21:08 +03:00
|
|
|
func (n *NetworkHarness) WaitForTxInMempool(ctx context.Context,
|
|
|
|
txid chainhash.Hash) error {
|
|
|
|
|
2017-10-25 05:54:18 +03:00
|
|
|
// Return immediately if harness has been torn down.
|
|
|
|
select {
|
|
|
|
case <-n.quit:
|
2017-11-03 21:52:02 +03:00
|
|
|
return fmt.Errorf("NetworkHarness has been torn down")
|
2017-10-25 05:54:18 +03:00
|
|
|
default:
|
|
|
|
}
|
|
|
|
|
2020-10-26 16:21:08 +03:00
|
|
|
ticker := time.NewTicker(50 * time.Millisecond)
|
|
|
|
defer ticker.Stop()
|
2016-08-31 05:34:13 +03:00
|
|
|
|
2020-10-26 16:21:08 +03:00
|
|
|
var mempool []*chainhash.Hash
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
|
|
|
return fmt.Errorf("wanted %v, found %v txs "+
|
|
|
|
"in mempool: %v", txid, len(mempool), mempool)
|
2016-08-31 05:34:13 +03:00
|
|
|
|
2020-10-26 16:21:08 +03:00
|
|
|
case <-ticker.C:
|
|
|
|
var err error
|
|
|
|
mempool, err = n.Miner.Node.GetRawMempool()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, mempoolTx := range mempool {
|
|
|
|
if *mempoolTx == txid {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
2016-08-31 05:34:13 +03:00
|
|
|
}
|
|
|
|
|
2018-08-22 10:32:42 +03:00
|
|
|
// OpenChannelParams houses the params to specify when opening a new channel.
|
|
|
|
type OpenChannelParams struct {
|
|
|
|
// Amt is the local amount being put into the channel.
|
|
|
|
Amt btcutil.Amount
|
|
|
|
|
|
|
|
// PushAmt is the amount that should be pushed to the remote when the
|
|
|
|
// channel is opened.
|
|
|
|
PushAmt btcutil.Amount
|
|
|
|
|
|
|
|
// Private is a boolan indicating whether the opened channel should be
|
|
|
|
// private.
|
|
|
|
Private bool
|
|
|
|
|
|
|
|
// SpendUnconfirmed is a boolean indicating whether we can utilize
|
|
|
|
// unconfirmed outputs to fund the channel.
|
|
|
|
SpendUnconfirmed bool
|
|
|
|
|
2018-09-06 11:48:46 +03:00
|
|
|
// MinHtlc is the htlc_minimum_msat value set when opening the channel.
|
2018-08-22 10:32:42 +03:00
|
|
|
MinHtlc lnwire.MilliSatoshi
|
2019-12-11 07:00:09 +03:00
|
|
|
|
2020-08-13 01:46:17 +03:00
|
|
|
// RemoteMaxHtlcs is the remote_max_htlcs value set when opening the
|
|
|
|
// channel, restricting the number of concurrent HTLCs the remote party
|
|
|
|
// can add to a commitment.
|
|
|
|
RemoteMaxHtlcs uint16
|
|
|
|
|
2019-12-11 07:00:09 +03:00
|
|
|
// FundingShim is an optional funding shim that the caller can specify
|
|
|
|
// in order to modify the channel funding workflow.
|
|
|
|
FundingShim *lnrpc.FundingShim
|
2018-08-22 10:32:42 +03:00
|
|
|
}
|
|
|
|
|
2016-10-15 16:18:38 +03:00
|
|
|
// OpenChannel attempts to open a channel between srcNode and destNode with the
|
2016-09-18 03:34:39 +03:00
|
|
|
// passed channel funding parameters. If the passed context has a timeout, then
|
2016-10-15 16:18:38 +03:00
|
|
|
// if the timeout is reached before the channel pending notification is
|
2018-08-10 07:17:06 +03:00
|
|
|
// received, an error is returned. The confirmed boolean determines whether we
|
|
|
|
// should fund the channel with confirmed outputs or not.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) OpenChannel(ctx context.Context,
|
2018-08-22 10:32:42 +03:00
|
|
|
srcNode, destNode *HarnessNode, p OpenChannelParams) (
|
|
|
|
lnrpc.Lightning_OpenChannelClient, error) {
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2017-07-12 02:27:11 +03:00
|
|
|
// Wait until srcNode and destNode have the latest chain synced.
|
|
|
|
// Otherwise, we may run into a check within the funding manager that
|
|
|
|
// prevents any funding workflows from being kicked off if the chain
|
|
|
|
// isn't yet synced.
|
2017-06-19 16:53:52 +03:00
|
|
|
if err := srcNode.WaitForBlockchainSync(ctx); err != nil {
|
2020-08-13 01:45:25 +03:00
|
|
|
return nil, fmt.Errorf("unable to sync srcNode chain: %v", err)
|
2017-06-19 16:53:52 +03:00
|
|
|
}
|
|
|
|
if err := destNode.WaitForBlockchainSync(ctx); err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return nil, fmt.Errorf("unable to sync destNode chain: %v", err)
|
2017-06-19 16:53:52 +03:00
|
|
|
}
|
|
|
|
|
2018-08-22 10:32:42 +03:00
|
|
|
minConfs := int32(1)
|
|
|
|
if p.SpendUnconfirmed {
|
|
|
|
minConfs = 0
|
2018-08-10 07:17:06 +03:00
|
|
|
}
|
|
|
|
|
2016-08-31 21:59:08 +03:00
|
|
|
openReq := &lnrpc.OpenChannelRequest{
|
2016-10-28 05:43:31 +03:00
|
|
|
NodePubkey: destNode.PubKey[:],
|
2018-08-22 10:32:42 +03:00
|
|
|
LocalFundingAmount: int64(p.Amt),
|
|
|
|
PushSat: int64(p.PushAmt),
|
|
|
|
Private: p.Private,
|
2018-08-10 07:17:06 +03:00
|
|
|
MinConfs: minConfs,
|
2018-10-17 03:02:07 +03:00
|
|
|
SpendUnconfirmed: p.SpendUnconfirmed,
|
2018-08-22 10:32:42 +03:00
|
|
|
MinHtlcMsat: int64(p.MinHtlc),
|
2020-08-13 01:46:17 +03:00
|
|
|
RemoteMaxHtlcs: uint32(p.RemoteMaxHtlcs),
|
2019-12-11 07:00:09 +03:00
|
|
|
FundingShim: p.FundingShim,
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
2016-09-15 21:59:51 +03:00
|
|
|
|
2016-08-31 21:59:08 +03:00
|
|
|
respStream, err := srcNode.OpenChannel(ctx, openReq)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("unable to open channel between "+
|
|
|
|
"alice and bob: %v", err)
|
|
|
|
}
|
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
chanOpen := make(chan struct{})
|
|
|
|
errChan := make(chan error)
|
|
|
|
go func() {
|
|
|
|
// Consume the "channel pending" update. This waits until the node
|
|
|
|
// notifies us that the final message in the channel funding workflow
|
|
|
|
// has been sent to the remote node.
|
|
|
|
resp, err := respStream.Recv()
|
|
|
|
if err != nil {
|
|
|
|
errChan <- err
|
2016-09-26 20:52:25 +03:00
|
|
|
return
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
|
|
|
if _, ok := resp.Update.(*lnrpc.OpenStatusUpdate_ChanPending); !ok {
|
|
|
|
errChan <- fmt.Errorf("expected channel pending update, "+
|
|
|
|
"instead got %v", resp)
|
2016-09-26 20:52:25 +03:00
|
|
|
return
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
close(chanOpen)
|
|
|
|
}()
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
2017-01-24 05:19:54 +03:00
|
|
|
return nil, fmt.Errorf("timeout reached before chan pending "+
|
|
|
|
"update sent: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
case err := <-errChan:
|
|
|
|
return nil, err
|
|
|
|
case <-chanOpen:
|
|
|
|
return respStream, nil
|
|
|
|
}
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
|
2017-01-31 07:21:52 +03:00
|
|
|
// OpenPendingChannel attempts to open a channel between srcNode and destNode with the
|
|
|
|
// passed channel funding parameters. If the passed context has a timeout, then
|
|
|
|
// if the timeout is reached before the channel pending notification is
|
|
|
|
// received, an error is returned.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) OpenPendingChannel(ctx context.Context,
|
|
|
|
srcNode, destNode *HarnessNode, amt btcutil.Amount,
|
2017-07-31 00:25:38 +03:00
|
|
|
pushAmt btcutil.Amount) (*lnrpc.PendingUpdate, error) {
|
2017-01-31 07:21:52 +03:00
|
|
|
|
2017-06-19 16:53:52 +03:00
|
|
|
// Wait until srcNode and destNode have blockchain synced
|
|
|
|
if err := srcNode.WaitForBlockchainSync(ctx); err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return nil, fmt.Errorf("unable to sync srcNode chain: %v", err)
|
2017-06-19 16:53:52 +03:00
|
|
|
}
|
|
|
|
if err := destNode.WaitForBlockchainSync(ctx); err != nil {
|
2020-04-14 20:56:05 +03:00
|
|
|
return nil, fmt.Errorf("unable to sync destNode chain: %v", err)
|
2017-06-19 16:53:52 +03:00
|
|
|
}
|
|
|
|
|
2017-01-31 07:21:52 +03:00
|
|
|
openReq := &lnrpc.OpenChannelRequest{
|
|
|
|
NodePubkey: destNode.PubKey[:],
|
|
|
|
LocalFundingAmount: int64(amt),
|
|
|
|
PushSat: int64(pushAmt),
|
2017-11-14 04:35:15 +03:00
|
|
|
Private: false,
|
2017-01-31 07:21:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
respStream, err := srcNode.OpenChannel(ctx, openReq)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("unable to open channel between "+
|
|
|
|
"alice and bob: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
chanPending := make(chan *lnrpc.PendingUpdate)
|
|
|
|
errChan := make(chan error)
|
|
|
|
go func() {
|
|
|
|
// Consume the "channel pending" update. This waits until the node
|
|
|
|
// notifies us that the final message in the channel funding workflow
|
|
|
|
// has been sent to the remote node.
|
|
|
|
resp, err := respStream.Recv()
|
|
|
|
if err != nil {
|
|
|
|
errChan <- err
|
|
|
|
return
|
|
|
|
}
|
|
|
|
pendingResp, ok := resp.Update.(*lnrpc.OpenStatusUpdate_ChanPending)
|
|
|
|
if !ok {
|
|
|
|
errChan <- fmt.Errorf("expected channel pending update, "+
|
|
|
|
"instead got %v", resp)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
chanPending <- pendingResp.ChanPending
|
|
|
|
}()
|
|
|
|
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
|
|
|
return nil, fmt.Errorf("timeout reached before chan pending " +
|
|
|
|
"update sent")
|
|
|
|
case err := <-errChan:
|
|
|
|
return nil, err
|
|
|
|
case pendingChan := <-chanPending:
|
|
|
|
return pendingChan, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-31 21:59:08 +03:00
|
|
|
// WaitForChannelOpen waits for a notification that a channel is open by
|
2016-09-18 03:34:39 +03:00
|
|
|
// consuming a message from the past open channel stream. If the passed context
|
|
|
|
// has a timeout, then if the timeout is reached before the channel has been
|
|
|
|
// opened, then an error is returned.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) WaitForChannelOpen(ctx context.Context,
|
2016-09-18 03:34:39 +03:00
|
|
|
openChanStream lnrpc.Lightning_OpenChannelClient) (*lnrpc.ChannelPoint, error) {
|
|
|
|
|
|
|
|
errChan := make(chan error)
|
|
|
|
respChan := make(chan *lnrpc.ChannelPoint)
|
|
|
|
go func() {
|
|
|
|
resp, err := openChanStream.Recv()
|
|
|
|
if err != nil {
|
|
|
|
errChan <- fmt.Errorf("unable to read rpc resp: %v", err)
|
2016-09-26 20:52:25 +03:00
|
|
|
return
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
|
|
|
fundingResp, ok := resp.Update.(*lnrpc.OpenStatusUpdate_ChanOpen)
|
|
|
|
if !ok {
|
|
|
|
errChan <- fmt.Errorf("expected channel open update, "+
|
|
|
|
"instead got %v", resp)
|
2016-09-26 20:52:25 +03:00
|
|
|
return
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
respChan <- fundingResp.ChanOpen.ChannelPoint
|
|
|
|
}()
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
|
|
|
return nil, fmt.Errorf("timeout reached while waiting for " +
|
|
|
|
"channel open")
|
|
|
|
case err := <-errChan:
|
|
|
|
return nil, err
|
|
|
|
case chanPoint := <-respChan:
|
|
|
|
return chanPoint, nil
|
|
|
|
}
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
|
2018-09-28 06:59:59 +03:00
|
|
|
// CloseChannel attempts to close the channel indicated by the
|
2016-09-18 03:34:39 +03:00
|
|
|
// passed channel point, initiated by the passed lnNode. If the passed context
|
2018-09-28 06:59:59 +03:00
|
|
|
// has a timeout, an error is returned if that timeout is reached before the
|
|
|
|
// channel close is pending.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) CloseChannel(ctx context.Context,
|
|
|
|
lnNode *HarnessNode, cp *lnrpc.ChannelPoint,
|
2017-01-06 00:56:27 +03:00
|
|
|
force bool) (lnrpc.Lightning_CloseChannelClient, *chainhash.Hash, error) {
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2017-11-19 03:38:30 +03:00
|
|
|
// Create a channel outpoint that we can use to compare to channels
|
|
|
|
// from the ListChannelsResponse.
|
2018-01-11 07:59:30 +03:00
|
|
|
txidHash, err := getChanPointFundingTxid(cp)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
fundingTxID, err := chainhash.NewHash(txidHash)
|
2017-11-19 03:38:30 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
chanPoint := wire.OutPoint{
|
|
|
|
Hash: *fundingTxID,
|
|
|
|
Index: cp.OutputIndex,
|
|
|
|
}
|
|
|
|
|
2017-12-21 13:43:07 +03:00
|
|
|
// We'll wait for *both* nodes to read the channel as active if we're
|
|
|
|
// performing a cooperative channel closure.
|
|
|
|
if !force {
|
|
|
|
timeout := time.Second * 15
|
2017-11-19 03:38:30 +03:00
|
|
|
listReq := &lnrpc.ListChannelsRequest{}
|
2017-12-21 13:43:07 +03:00
|
|
|
|
|
|
|
// We define two helper functions, one two locate a particular
|
|
|
|
// channel, and the other to check if a channel is active or
|
|
|
|
// not.
|
|
|
|
filterChannel := func(node *HarnessNode,
|
2018-03-13 22:11:30 +03:00
|
|
|
op wire.OutPoint) (*lnrpc.Channel, error) {
|
2017-12-21 13:43:07 +03:00
|
|
|
listResp, err := node.ListChannels(ctx, listReq)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, c := range listResp.Channels {
|
|
|
|
if c.ChannelPoint == op.String() {
|
|
|
|
return c, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, fmt.Errorf("unable to find channel")
|
2017-11-19 03:38:30 +03:00
|
|
|
}
|
2017-12-21 13:43:07 +03:00
|
|
|
activeChanPredicate := func(node *HarnessNode) func() bool {
|
|
|
|
return func() bool {
|
|
|
|
channel, err := filterChannel(node, chanPoint)
|
|
|
|
if err != nil {
|
2018-04-18 15:19:58 +03:00
|
|
|
return false
|
2017-12-21 13:43:07 +03:00
|
|
|
}
|
2017-11-19 03:38:30 +03:00
|
|
|
|
2017-12-21 13:43:07 +03:00
|
|
|
return channel.Active
|
2017-11-19 03:38:30 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-21 13:43:07 +03:00
|
|
|
// Next, we'll fetch the target channel in order to get the
|
2018-02-07 06:11:11 +03:00
|
|
|
// harness node that will be receiving the channel close request.
|
2017-12-21 13:43:07 +03:00
|
|
|
targetChan, err := filterChannel(lnNode, chanPoint)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
receivingNode, err := n.LookUpNodeByPub(targetChan.RemotePubkey)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
2017-11-19 03:38:30 +03:00
|
|
|
}
|
|
|
|
|
2017-12-21 13:43:07 +03:00
|
|
|
// Before proceeding, we'll ensure that the channel is active
|
|
|
|
// for both nodes.
|
2019-09-19 22:46:29 +03:00
|
|
|
err = wait.Predicate(activeChanPredicate(lnNode), timeout)
|
2017-12-21 13:43:07 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, fmt.Errorf("channel of closing " +
|
|
|
|
"node not active in time")
|
|
|
|
}
|
2019-09-19 22:46:29 +03:00
|
|
|
err = wait.Predicate(activeChanPredicate(receivingNode), timeout)
|
2017-12-21 13:43:07 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, fmt.Errorf("channel of receiving " +
|
|
|
|
"node not active in time")
|
|
|
|
}
|
2017-11-19 03:38:30 +03:00
|
|
|
}
|
|
|
|
|
2016-08-31 21:59:08 +03:00
|
|
|
closeReq := &lnrpc.CloseChannelRequest{
|
2016-09-12 22:33:22 +03:00
|
|
|
ChannelPoint: cp,
|
|
|
|
Force: force,
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
closeRespStream, err := lnNode.CloseChannel(ctx, closeReq)
|
|
|
|
if err != nil {
|
2016-12-14 02:32:44 +03:00
|
|
|
return nil, nil, fmt.Errorf("unable to close channel: %v", err)
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
errChan := make(chan error)
|
2017-01-06 00:56:27 +03:00
|
|
|
fin := make(chan *chainhash.Hash)
|
2016-09-18 03:34:39 +03:00
|
|
|
go func() {
|
|
|
|
// Consume the "channel close" update in order to wait for the closing
|
|
|
|
// transaction to be broadcast, then wait for the closing tx to be seen
|
|
|
|
// within the network.
|
|
|
|
closeResp, err := closeRespStream.Recv()
|
|
|
|
if err != nil {
|
2020-03-09 17:10:14 +03:00
|
|
|
errChan <- fmt.Errorf("unable to recv() from close "+
|
|
|
|
"stream: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
pendingClose, ok := closeResp.Update.(*lnrpc.CloseStatusUpdate_ClosePending)
|
|
|
|
if !ok {
|
|
|
|
errChan <- fmt.Errorf("expected channel close update, "+
|
|
|
|
"instead got %v", pendingClose)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-01-06 00:56:27 +03:00
|
|
|
closeTxid, err := chainhash.NewHash(pendingClose.ClosePending.Txid)
|
2016-09-18 03:34:39 +03:00
|
|
|
if err != nil {
|
2020-03-09 17:10:14 +03:00
|
|
|
errChan <- fmt.Errorf("unable to decode closeTxid: "+
|
|
|
|
"%v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
return
|
|
|
|
}
|
2020-10-26 16:21:08 +03:00
|
|
|
if err := n.WaitForTxInMempool(ctx, *closeTxid); err != nil {
|
2020-03-09 17:10:14 +03:00
|
|
|
errChan <- fmt.Errorf("error while waiting for "+
|
|
|
|
"broadcast tx: %v", err)
|
2016-09-18 03:34:39 +03:00
|
|
|
return
|
|
|
|
}
|
2016-12-14 02:32:44 +03:00
|
|
|
fin <- closeTxid
|
2016-09-18 03:34:39 +03:00
|
|
|
}()
|
|
|
|
|
|
|
|
// Wait until either the deadline for the context expires, an error
|
|
|
|
// occurs, or the channel close update is received.
|
|
|
|
select {
|
|
|
|
case err := <-errChan:
|
2016-12-14 02:32:44 +03:00
|
|
|
return nil, nil, err
|
|
|
|
case closeTxid := <-fin:
|
|
|
|
return closeRespStream, closeTxid, nil
|
2016-09-14 04:56:35 +03:00
|
|
|
}
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// WaitForChannelClose waits for a notification from the passed channel close
|
2016-09-18 03:34:39 +03:00
|
|
|
// stream that the node has deemed the channel has been fully closed. If the
|
|
|
|
// passed context has a timeout, then if the timeout is reached before the
|
|
|
|
// notification is received then an error is returned.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) WaitForChannelClose(ctx context.Context,
|
2017-01-06 00:56:27 +03:00
|
|
|
closeChanStream lnrpc.Lightning_CloseChannelClient) (*chainhash.Hash, error) {
|
2016-09-18 03:34:39 +03:00
|
|
|
|
|
|
|
errChan := make(chan error)
|
|
|
|
updateChan := make(chan *lnrpc.CloseStatusUpdate_ChanClose)
|
|
|
|
go func() {
|
|
|
|
closeResp, err := closeChanStream.Recv()
|
|
|
|
if err != nil {
|
|
|
|
errChan <- err
|
|
|
|
return
|
|
|
|
}
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2016-09-18 03:34:39 +03:00
|
|
|
closeFin, ok := closeResp.Update.(*lnrpc.CloseStatusUpdate_ChanClose)
|
|
|
|
if !ok {
|
|
|
|
errChan <- fmt.Errorf("expected channel close update, "+
|
|
|
|
"instead got %v", closeFin)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
updateChan <- closeFin
|
|
|
|
}()
|
|
|
|
|
|
|
|
// Wait until either the deadline for the context expires, an error
|
|
|
|
// occurs, or the channel close update is received.
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
|
|
|
return nil, fmt.Errorf("timeout reached before update sent")
|
|
|
|
case err := <-errChan:
|
|
|
|
return nil, err
|
|
|
|
case update := <-updateChan:
|
2017-01-06 00:56:27 +03:00
|
|
|
return chainhash.NewHash(update.ChanClose.ClosingTxid)
|
2016-09-18 03:34:39 +03:00
|
|
|
}
|
2016-08-31 21:59:08 +03:00
|
|
|
}
|
|
|
|
|
2018-05-23 08:45:55 +03:00
|
|
|
// AssertChannelExists asserts that an active channel identified by the
|
2020-07-29 10:27:22 +03:00
|
|
|
// specified channel point exists from the point-of-view of the node. It takes
|
|
|
|
// an optional set of check functions which can be used to make further
|
|
|
|
// assertions using channel's values. These functions are responsible for
|
|
|
|
// failing the test themselves if they do not pass.
|
|
|
|
// nolint: interfacer
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) AssertChannelExists(ctx context.Context,
|
2020-07-29 10:27:22 +03:00
|
|
|
node *HarnessNode, chanPoint *wire.OutPoint,
|
|
|
|
checks ...func(*lnrpc.Channel)) error {
|
2016-08-31 21:59:08 +03:00
|
|
|
|
2016-09-26 20:31:07 +03:00
|
|
|
req := &lnrpc.ListChannelsRequest{}
|
2017-12-21 13:35:23 +03:00
|
|
|
|
2019-11-20 07:12:48 +03:00
|
|
|
return wait.NoError(func() error {
|
2017-12-21 13:35:23 +03:00
|
|
|
resp, err := node.ListChannels(ctx, req)
|
|
|
|
if err != nil {
|
2019-11-20 07:12:48 +03:00
|
|
|
return fmt.Errorf("unable fetch node's channels: %v", err)
|
2017-12-21 13:35:23 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, channel := range resp.Channels {
|
|
|
|
if channel.ChannelPoint == chanPoint.String() {
|
2020-07-29 10:27:22 +03:00
|
|
|
// First check whether our channel is active,
|
|
|
|
// failing early if it is not.
|
|
|
|
if !channel.Active {
|
|
|
|
return fmt.Errorf("channel %s inactive",
|
|
|
|
chanPoint)
|
2019-11-20 07:12:48 +03:00
|
|
|
}
|
2017-12-21 13:35:23 +03:00
|
|
|
|
2020-07-29 10:27:22 +03:00
|
|
|
// Apply any additional checks that we would
|
|
|
|
// like to verify.
|
|
|
|
for _, check := range checks {
|
|
|
|
check(channel)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2019-11-20 07:12:48 +03:00
|
|
|
}
|
2017-12-21 13:35:23 +03:00
|
|
|
}
|
|
|
|
|
2019-11-20 07:12:48 +03:00
|
|
|
return fmt.Errorf("channel %s not found", chanPoint)
|
|
|
|
}, 15*time.Second)
|
2017-12-21 13:35:23 +03:00
|
|
|
}
|
|
|
|
|
2016-09-10 23:14:28 +03:00
|
|
|
// DumpLogs reads the current logs generated by the passed node, and returns
|
|
|
|
// the logs as a single string. This function is useful for examining the logs
|
|
|
|
// of a particular node in the case of a test failure.
|
2016-09-15 21:59:51 +03:00
|
|
|
// Logs from lightning node being generated with delay - you should
|
|
|
|
// add time.Sleep() in order to get all logs.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) DumpLogs(node *HarnessNode) (string, error) {
|
2019-12-17 12:48:17 +03:00
|
|
|
logFile := fmt.Sprintf("%v/simnet/lnd.log", node.Cfg.LogDir)
|
2016-09-10 23:14:28 +03:00
|
|
|
|
2016-09-15 21:59:51 +03:00
|
|
|
buf, err := ioutil.ReadFile(logFile)
|
2016-08-30 07:55:01 +03:00
|
|
|
if err != nil {
|
2016-09-10 23:14:28 +03:00
|
|
|
return "", err
|
2016-08-30 07:55:01 +03:00
|
|
|
}
|
|
|
|
|
2016-09-15 21:59:51 +03:00
|
|
|
return string(buf), nil
|
2016-08-30 07:55:01 +03:00
|
|
|
}
|
2016-09-26 20:31:07 +03:00
|
|
|
|
2017-01-12 01:21:04 +03:00
|
|
|
// SendCoins attempts to send amt satoshis from the internal mining node to the
|
2018-08-10 07:16:20 +03:00
|
|
|
// targeted lightning node using a P2WKH address. 6 blocks are mined after in
|
|
|
|
// order to confirm the transaction.
|
2017-11-03 21:52:02 +03:00
|
|
|
func (n *NetworkHarness) SendCoins(ctx context.Context, amt btcutil.Amount,
|
|
|
|
target *HarnessNode) error {
|
2016-09-26 20:31:07 +03:00
|
|
|
|
2018-04-03 02:57:04 +03:00
|
|
|
return n.sendCoins(
|
2018-09-27 16:49:44 +03:00
|
|
|
ctx, amt, target, lnrpc.AddressType_WITNESS_PUBKEY_HASH,
|
2018-08-10 07:16:20 +03:00
|
|
|
true,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SendCoinsUnconfirmed sends coins from the internal mining node to the target
|
|
|
|
// lightning node using a P2WPKH address. No blocks are mined after, so the
|
|
|
|
// transaction remains unconfirmed.
|
|
|
|
func (n *NetworkHarness) SendCoinsUnconfirmed(ctx context.Context,
|
|
|
|
amt btcutil.Amount, target *HarnessNode) error {
|
|
|
|
|
|
|
|
return n.sendCoins(
|
2018-09-27 16:49:44 +03:00
|
|
|
ctx, amt, target, lnrpc.AddressType_WITNESS_PUBKEY_HASH,
|
2018-08-10 07:16:20 +03:00
|
|
|
false,
|
2018-04-03 02:57:04 +03:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SendCoinsNP2WKH attempts to send amt satoshis from the internal mining node
|
|
|
|
// to the targeted lightning node using a NP2WKH address.
|
|
|
|
func (n *NetworkHarness) SendCoinsNP2WKH(ctx context.Context,
|
|
|
|
amt btcutil.Amount, target *HarnessNode) error {
|
|
|
|
|
|
|
|
return n.sendCoins(
|
2018-09-27 16:49:44 +03:00
|
|
|
ctx, amt, target, lnrpc.AddressType_NESTED_PUBKEY_HASH,
|
2018-08-10 07:16:20 +03:00
|
|
|
true,
|
2018-04-03 02:57:04 +03:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
// sendCoins attempts to send amt satoshis from the internal mining node to the
|
2018-08-10 07:16:20 +03:00
|
|
|
// targeted lightning node. The confirmed boolean indicates whether the
|
|
|
|
// transaction that pays to the target should confirm.
|
2018-04-03 02:57:04 +03:00
|
|
|
func (n *NetworkHarness) sendCoins(ctx context.Context, amt btcutil.Amount,
|
2018-09-27 16:49:44 +03:00
|
|
|
target *HarnessNode, addrType lnrpc.AddressType,
|
2018-08-10 07:16:20 +03:00
|
|
|
confirmed bool) error {
|
2018-04-03 02:57:04 +03:00
|
|
|
|
2016-09-26 21:54:13 +03:00
|
|
|
balReq := &lnrpc.WalletBalanceRequest{}
|
|
|
|
initialBalance, err := target.WalletBalance(ctx, balReq)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-09-26 20:31:07 +03:00
|
|
|
// First, obtain an address from the target lightning node, preferring
|
|
|
|
// to receive a p2wkh address s.t the output can immediately be used as
|
|
|
|
// an input to a funding transaction.
|
|
|
|
addrReq := &lnrpc.NewAddressRequest{
|
2018-04-03 02:57:04 +03:00
|
|
|
Type: addrType,
|
2016-09-26 20:31:07 +03:00
|
|
|
}
|
|
|
|
resp, err := target.NewAddress(ctx, addrReq)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
addr, err := btcutil.DecodeAddress(resp.Address, n.netParams)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
addrScript, err := txscript.PayToAddrScript(addr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generate a transaction which creates an output to the target
|
|
|
|
// pkScript of the desired amount.
|
|
|
|
output := &wire.TxOut{
|
|
|
|
PkScript: addrScript,
|
|
|
|
Value: int64(amt),
|
|
|
|
}
|
2018-07-28 04:20:58 +03:00
|
|
|
_, err = n.Miner.SendOutputs([]*wire.TxOut{output}, 7500)
|
|
|
|
if err != nil {
|
2016-09-26 20:31:07 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-02-12 00:02:11 +03:00
|
|
|
// Encode the pkScript in hex as this the format that it will be
|
|
|
|
// returned via rpc.
|
|
|
|
expPkScriptStr := hex.EncodeToString(addrScript)
|
|
|
|
|
|
|
|
// Now, wait for ListUnspent to show the unconfirmed transaction
|
|
|
|
// containing the correct pkscript.
|
2019-09-19 22:46:29 +03:00
|
|
|
err = wait.NoError(func() error {
|
2019-05-24 15:17:49 +03:00
|
|
|
// Since neutrino doesn't support unconfirmed outputs, skip
|
|
|
|
// this check.
|
2019-12-17 12:48:17 +03:00
|
|
|
if target.Cfg.BackendCfg.Name() == "neutrino" {
|
2019-05-24 15:17:49 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-02-12 00:02:11 +03:00
|
|
|
req := &lnrpc.ListUnspentRequest{}
|
|
|
|
resp, err := target.ListUnspent(ctx, req)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// When using this method, there should only ever be on
|
|
|
|
// unconfirmed transaction.
|
|
|
|
if len(resp.Utxos) != 1 {
|
|
|
|
return fmt.Errorf("number of unconfirmed utxos "+
|
|
|
|
"should be 1, found %d", len(resp.Utxos))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Assert that the lone unconfirmed utxo contains the same
|
|
|
|
// pkscript as the output generated above.
|
2019-02-12 00:02:25 +03:00
|
|
|
pkScriptStr := resp.Utxos[0].PkScript
|
2019-02-12 00:02:11 +03:00
|
|
|
if strings.Compare(pkScriptStr, expPkScriptStr) != 0 {
|
|
|
|
return fmt.Errorf("pkscript mismatch, want: %s, "+
|
|
|
|
"found: %s", expPkScriptStr, pkScriptStr)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}, 15*time.Second)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("unconfirmed utxo was not found in "+
|
|
|
|
"ListUnspent: %v", err)
|
|
|
|
}
|
|
|
|
|
2018-08-10 07:16:20 +03:00
|
|
|
// If the transaction should remain unconfirmed, then we'll wait until
|
|
|
|
// the target node's unconfirmed balance reflects the expected balance
|
|
|
|
// and exit.
|
|
|
|
if !confirmed {
|
2018-09-10 16:02:06 +03:00
|
|
|
expectedBalance := btcutil.Amount(initialBalance.UnconfirmedBalance) + amt
|
2018-08-10 07:16:20 +03:00
|
|
|
return target.WaitForBalance(expectedBalance, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we'll generate 6 new blocks to ensure the output gains a
|
|
|
|
// sufficient number of confirmations and wait for the balance to
|
|
|
|
// reflect what's expected.
|
2016-09-26 20:31:07 +03:00
|
|
|
if _, err := n.Miner.Node.Generate(6); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-09-10 16:02:06 +03:00
|
|
|
expectedBalance := btcutil.Amount(initialBalance.ConfirmedBalance) + amt
|
2018-08-10 07:15:40 +03:00
|
|
|
return target.WaitForBalance(expectedBalance, true)
|
2016-09-26 20:31:07 +03:00
|
|
|
}
|
2018-10-10 13:55:14 +03:00
|
|
|
|
2020-09-10 16:48:39 +03:00
|
|
|
func (n *NetworkHarness) SetFeeEstimate(fee chainfee.SatPerKWeight) {
|
|
|
|
n.feeService.setFee(fee)
|
|
|
|
}
|
|
|
|
|
2018-10-10 13:55:14 +03:00
|
|
|
// CopyFile copies the file src to dest.
|
|
|
|
func CopyFile(dest, src string) error {
|
|
|
|
s, err := os.Open(src)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer s.Close()
|
|
|
|
|
|
|
|
d, err := os.Create(dest)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err := io.Copy(d, s); err != nil {
|
|
|
|
d.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return d.Close()
|
|
|
|
}
|
2020-10-26 18:36:09 +03:00
|
|
|
|
|
|
|
// FileExists returns true if the file at path exists.
|
|
|
|
func FileExists(path string) bool {
|
|
|
|
if _, err := os.Stat(path); os.IsNotExist(err) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// CopyAll copies all files and directories from srcDir to dstDir recursively.
|
|
|
|
// Note that this function does not support links.
|
|
|
|
func CopyAll(dstDir, srcDir string) error {
|
|
|
|
entries, err := ioutil.ReadDir(srcDir)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, entry := range entries {
|
|
|
|
srcPath := filepath.Join(srcDir, entry.Name())
|
|
|
|
dstPath := filepath.Join(dstDir, entry.Name())
|
|
|
|
|
|
|
|
info, err := os.Stat(srcPath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if info.IsDir() {
|
|
|
|
err := os.Mkdir(dstPath, info.Mode())
|
|
|
|
if err != nil && !os.IsExist(err) {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = CopyAll(dstPath, srcPath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
} else if err := CopyFile(dstPath, srcPath); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|