lntemp+itest: remove unused code to prepare lntemp's takeover

This commit removes the old code living in `lntest` to prepare
`lntemp`'s takeover.

itest/lnd_channel_force_close_test.go

@@ -1087,3 +1087,71 @@ func assertReports(ht *lntemp.HarnessTest, hn *node.HarnessNode,
 		require.Equal(ht, expected, res)
 	}
 }
+
+// checkCommitmentMaturity checks that both the maturity height and blocks
+// maturity height are as expected.
+//
+// NOTE: only used in current test file.
+func checkCommitmentMaturity(forceClose lntemp.PendingForceClose,
+	maturityHeight uint32, blocksTilMaturity int32) error {
+
+	if forceClose.MaturityHeight != maturityHeight {
+		return fmt.Errorf("expected commitment maturity height to be "+
+			"%d, found %d instead", maturityHeight,
+			forceClose.MaturityHeight)
+	}
+	if forceClose.BlocksTilMaturity != blocksTilMaturity {
+		return fmt.Errorf("expected commitment blocks til maturity to "+
+			"be %d, found %d instead", blocksTilMaturity,
+			forceClose.BlocksTilMaturity)
+	}
+
+	return nil
+}
+
+// checkForceClosedChannelNumHtlcs verifies that a force closed channel has the
+// proper number of htlcs.
+//
+// NOTE: only used in current test file.
+func checkPendingChannelNumHtlcs(
+	forceClose *lnrpc.PendingChannelsResponse_ForceClosedChannel,
+	expectedNumHtlcs int) error {
+
+	if len(forceClose.PendingHtlcs) != expectedNumHtlcs {
+		return fmt.Errorf("expected force closed channel to have %d "+
+			"pending htlcs, found %d instead", expectedNumHtlcs,
+			len(forceClose.PendingHtlcs))
+	}
+
+	return nil
+}
+
+// checkPendingHtlcStageAndMaturity uniformly tests all pending htlc's belonging
+// to a force closed channel, testing for the expected stage number, blocks till
+// maturity, and the maturity height.
+//
+// NOTE: only used in current test file.
+func checkPendingHtlcStageAndMaturity(
+	forceClose *lnrpc.PendingChannelsResponse_ForceClosedChannel,
+	stage, maturityHeight uint32, blocksTillMaturity int32) error {
+
+	for _, pendingHtlc := range forceClose.PendingHtlcs {
+		if pendingHtlc.Stage != stage {
+			return fmt.Errorf("expected pending htlc to be stage "+
+				"%d, found %d", stage, pendingHtlc.Stage)
+		}
+		if pendingHtlc.MaturityHeight != maturityHeight {
+			return fmt.Errorf("expected pending htlc maturity "+
+				"height to be %d, instead has %d",
+				maturityHeight, pendingHtlc.MaturityHeight)
+		}
+		if pendingHtlc.BlocksTilMaturity != blocksTillMaturity {
+			return fmt.Errorf("expected pending htlc blocks til "+
+				"maturity to be %d, instead has %d",
+				blocksTillMaturity,
+				pendingHtlc.BlocksTilMaturity)
+		}
+	}
+
+	return nil
+}

itest/lnd_channel_policy_test.go

@@ -12,25 +12,10 @@ import (
 	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
 	"github.com/lightningnetwork/lnd/lntemp"
 	"github.com/lightningnetwork/lnd/lntemp/node"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/stretchr/testify/require"
 )
 
-// assertPolicyUpdate checks that a given policy update has been received by a
-// list of given nodes.
-// TODO(yy): delete.
-func assertPolicyUpdate(t *harnessTest, nodes []*lntest.HarnessNode,
-	advertisingNode string, policy *lnrpc.RoutingPolicy,
-	chanPoint *lnrpc.ChannelPoint) {
-
-	for _, node := range nodes {
-		assertChannelPolicyUpdate(
-			t.t, node, advertisingNode, policy, chanPoint, false,
-		)
-	}
-}
-
 // testUpdateChannelPolicy tests that policy updates made to a channel
 // gets propagated to other nodes in the network.
 func testUpdateChannelPolicy(ht *lntemp.HarnessTest) {

itest/lnd_etcd_failover_test.go

@@ -13,7 +13,7 @@ import (
 	"github.com/lightningnetwork/lnd/lncfg"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lntemp"
-	"github.com/lightningnetwork/lnd/lntest"
+	"github.com/lightningnetwork/lnd/lntemp/node"
 	"github.com/stretchr/testify/require"
 )
 
@@ -56,8 +56,8 @@ func testEtcdFailover(ht *lntemp.HarnessTest) {
 
 func testEtcdFailoverCase(ht *lntemp.HarnessTest, kill bool) {
 	etcdCfg, cleanup, err := kvdb.StartEtcdTestBackend(
-		ht.T.TempDir(), uint16(lntest.NextAvailablePort()),
-		uint16(lntest.NextAvailablePort()), "",
+		ht.T.TempDir(), uint16(node.NextAvailablePort()),
+		uint16(node.NextAvailablePort()), "",
 	)
 	require.NoError(ht, err, "Failed to start etcd instance")
 	defer cleanup()

itest/lnd_multi-hop_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/lightningnetwork/lnd/lntemp"
 	"github.com/lightningnetwork/lnd/lntemp/node"
 	"github.com/lightningnetwork/lnd/lntemp/rpc"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/routing"
 	"github.com/stretchr/testify/require"
@@ -52,102 +51,6 @@ var commitWithZeroConf = []struct {
 	},
 }
 
-// waitForInvoiceAccepted waits until the specified invoice moved to the
-// accepted state by the node.
-func waitForInvoiceAccepted(t *harnessTest, node *lntest.HarnessNode,
-	payHash lntypes.Hash) {
-
-	ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
-	defer cancel()
-	invoiceUpdates, err := node.SubscribeSingleInvoice(ctx,
-		&invoicesrpc.SubscribeSingleInvoiceRequest{
-			RHash: payHash[:],
-		},
-	)
-	if err != nil {
-		t.Fatalf("subscribe single invoice: %v", err)
-	}
-
-	for {
-		update, err := invoiceUpdates.Recv()
-		if err != nil {
-			t.Fatalf("invoice update err: %v", err)
-		}
-		if update.State == lnrpc.Invoice_ACCEPTED {
-			break
-		}
-	}
-}
-
-// checkPaymentStatus asserts that the given node list a payment with the given
-// preimage has the expected status.
-func checkPaymentStatus(node *lntest.HarnessNode, preimage lntypes.Preimage,
-	status lnrpc.Payment_PaymentStatus) error {
-
-	ctxb := context.Background()
-	ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
-	defer cancel()
-
-	req := &lnrpc.ListPaymentsRequest{
-		IncludeIncomplete: true,
-	}
-	paymentsResp, err := node.ListPayments(ctxt, req)
-	if err != nil {
-		return fmt.Errorf("error when obtaining Alice payments: %v",
-			err)
-	}
-
-	payHash := preimage.Hash()
-	var found bool
-	for _, p := range paymentsResp.Payments {
-		if p.PaymentHash != payHash.String() {
-			continue
-		}
-
-		found = true
-		if p.Status != status {
-			return fmt.Errorf("expected payment status "+
-				"%v, got %v", status, p.Status)
-		}
-
-		switch status {
-		// If this expected status is SUCCEEDED, we expect the final preimage.
-		case lnrpc.Payment_SUCCEEDED:
-			if p.PaymentPreimage != preimage.String() {
-				return fmt.Errorf("preimage doesn't match: %v vs %v",
-					p.PaymentPreimage, preimage.String())
-			}
-
-		// Otherwise we expect an all-zero preimage.
-		default:
-			if p.PaymentPreimage != (lntypes.Preimage{}).String() {
-				return fmt.Errorf("expected zero preimage, got %v",
-					p.PaymentPreimage)
-			}
-		}
-	}
-
-	if !found {
-		return fmt.Errorf("payment with payment hash %v not found "+
-			"in response", payHash)
-	}
-
-	return nil
-}
-
-// assertAllTxesSpendFrom asserts that all txes in the list spend from the given
-// tx.
-func assertAllTxesSpendFrom(t *harnessTest, txes []*wire.MsgTx,
-	prevTxid chainhash.Hash) {
-
-	for _, tx := range txes {
-		if tx.TxIn[0].PreviousOutPoint.Hash != prevTxid {
-			t.Fatalf("tx %v did not spend from %v",
-				tx.TxHash(), prevTxid)
-		}
-	}
-}
-
 // caseRunner defines a single test case runner.
 type caseRunner func(ht *lntemp.HarnessTest, alice, bob *node.HarnessNode,
 	c lnrpc.CommitmentType, zeroConf bool)

itest/lnd_network_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lntemp"
 	"github.com/lightningnetwork/lnd/lntemp/node"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/stretchr/testify/require"
 )
@@ -105,7 +104,7 @@ func testReconnectAfterIPChange(ht *lntemp.HarnessTest) {
 
 	// We derive an extra port for Dave, and we initialise his node with
 	// the port advertised as `--externalip` arguments.
-	ip2 := lntest.NextAvailablePort()
+	ip2 := node.NextAvailablePort()
 
 	// Create a new node, Dave, which will initialize a P2P port for him.
 	daveArgs := []string{fmt.Sprintf("--externalip=127.0.0.1:%d", ip2)}
@@ -184,7 +183,7 @@ func testReconnectAfterIPChange(ht *lntemp.HarnessTest) {
 	// address.
 
 	// Change Dave's listening port and restart.
-	dave.Cfg.P2PPort = lntest.NextAvailablePort()
+	dave.Cfg.P2PPort = node.NextAvailablePort()
 	dave.Cfg.ExtraArgs = []string{
 		fmt.Sprintf(
 			"--externalip=127.0.0.1:%d", dave.Cfg.P2PPort,

itest/lnd_neutrino_test.go

@@ -3,14 +3,13 @@ package itest
 import (
 	"github.com/lightningnetwork/lnd/lnrpc/neutrinorpc"
 	"github.com/lightningnetwork/lnd/lntemp"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/stretchr/testify/require"
 )
 
 // testNeutrino checks that the neutrino sub-server can fetch compact
 // block filters, server status and connect to a connected peer.
 func testNeutrino(ht *lntemp.HarnessTest) {
-	if ht.ChainBackendName() != lntest.NeutrinoBackendName {
+	if !ht.IsNeutrinoBackend() {
 		ht.Skipf("skipping test for non neutrino backends")
 	}
 

itest/lnd_psbt_test.go

@@ -22,7 +22,6 @@ import (
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/lightningnetwork/lnd/lntemp"
 	"github.com/lightningnetwork/lnd/lntemp/node"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/stretchr/testify/require"
 )
 
@@ -1187,60 +1186,6 @@ func deriveInternalKey(ht *lntemp.HarnessTest,
 	return keyDesc, parsedPubKey, fullDerivationPath
 }
 
-// openChannelPsbt 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. An error is returned if the expected step
-// of funding the PSBT is not received from the source node.
-func openChannelPsbt(ctx context.Context, srcNode, destNode *lntest.HarnessNode,
-	p lntest.OpenChannelParams) (lnrpc.Lightning_OpenChannelClient, []byte,
-	error) {
-
-	// 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.
-	if err := srcNode.WaitForBlockchainSync(); err != nil {
-		return nil, nil, fmt.Errorf("unable to sync srcNode chain: %v",
-			err)
-	}
-	if err := destNode.WaitForBlockchainSync(); err != nil {
-		return nil, nil, fmt.Errorf("unable to sync destNode chain: %v",
-			err)
-	}
-
-	// Send the request to open a channel to the source node now. This will
-	// open a long-lived stream where we'll receive status updates about the
-	// progress of the channel.
-	respStream, err := srcNode.OpenChannel(ctx, &lnrpc.OpenChannelRequest{
-		NodePubkey:         destNode.PubKey[:],
-		LocalFundingAmount: int64(p.Amt),
-		PushSat:            int64(p.PushAmt),
-		Private:            p.Private,
-		SpendUnconfirmed:   p.SpendUnconfirmed,
-		MinHtlcMsat:        int64(p.MinHtlc),
-		FundingShim:        p.FundingShim,
-	})
-	if err != nil {
-		return nil, nil, fmt.Errorf("unable to open channel between "+
-			"source and dest: %v", err)
-	}
-
-	// Consume the "PSBT funding ready" update. This waits until the node
-	// notifies us that the PSBT can now be funded.
-	resp, err := receiveChanUpdate(ctx, respStream)
-	if err != nil {
-		return nil, nil, fmt.Errorf("unable to consume channel update "+
-			"message: %v", err)
-	}
-	upd, ok := resp.Update.(*lnrpc.OpenStatusUpdate_PsbtFund)
-	if !ok {
-		return nil, nil, fmt.Errorf("expected PSBT funding update, "+
-			"instead got %v", resp)
-	}
-	return respStream, upd.PsbtFund.Psbt, nil
-}
-
 // receiveChanUpdate waits until a message is received on the stream or the
 // context is canceled. The context must have a timeout or must be canceled
 // in case no message is received, otherwise this function will block forever.

itest/lnd_revocation_test.go

@@ -13,7 +13,6 @@ import (
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/wtclientrpc"
 	"github.com/lightningnetwork/lnd/lntemp"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/stretchr/testify/require"
 )
@@ -158,7 +157,7 @@ func testRevokedCloseRetribution(ht *lntemp.HarnessTest) {
 	// tx's confHeight+CSV-1 blocks and since we've already mined one that
 	// included the justice tx we only need to mine extra DefaultCSV-2
 	// blocks to unlock it.
-	ht.MineBlocks(lntest.DefaultCSV - 2)
+	ht.MineBlocks(defaultCSV - 2)
 
 	ht.AssertNumPendingForceClose(bob, 0)
 }

itest/lnd_test.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/btcsuite/btcd/integration/rpctest"
 	"github.com/lightningnetwork/lnd/lntemp"
-	"github.com/lightningnetwork/lnd/lntest"
+	"github.com/lightningnetwork/lnd/lntemp/node"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc/grpclog"
 )
@@ -62,7 +62,7 @@ func TestLightningNetworkDaemon(t *testing.T) {
 
 	// Get the test cases to be run in this tranche.
 	testCases, trancheIndex, trancheOffset := getTestCaseSplitTranche()
-	lntest.ApplyPortOffset(uint32(trancheIndex) * 1000)
+	node.ApplyPortOffset(uint32(trancheIndex) * 1000)
 
 	// Create a simple fee service.
 	feeService := lntemp.NewFeeService(t)
@@ -188,7 +188,7 @@ func init() {
 	// Before we start any node, we need to make sure that any btcd node
 	// that is started through the RPC harness uses a unique port as well
 	// to avoid any port collisions.
-	rpctest.ListenAddressGenerator = lntest.GenerateBtcdListenerAddresses
+	rpctest.ListenAddressGenerator = node.GenerateBtcdListenerAddresses
 
 	// Swap out grpc's default logger with out fake logger which drops the
 	// statements on the floor.

itest/lnd_zero_conf_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/lightningnetwork/lnd/lntemp"
 	"github.com/lightningnetwork/lnd/lntemp/node"
 	"github.com/lightningnetwork/lnd/lntemp/rpc"
-	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/stretchr/testify/require"
@@ -893,7 +892,7 @@ func acceptChannel(t *testing.T, zeroConf bool, stream rpc.AcceptorClient) {
 // be deleted from the channel graph. This was previously the case due to logic
 // in the function DisconnectBlockAtHeight.
 func testZeroConfReorg(ht *lntemp.HarnessTest) {
-	if ht.ChainBackendName() == lntest.NeutrinoBackendName {
+	if ht.IsNeutrinoBackend() {
 		ht.Skipf("skipping zero-conf reorg test for neutrino backend")
 	}
 

itest/test_harness.go

@@ -1,351 +0,0 @@
-package itest
-
-import (
-	"bytes"
-	"context"
-	"flag"
-	"fmt"
-	"math"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-	"time"
-
-	"github.com/btcsuite/btcd/chaincfg"
-	"github.com/btcsuite/btcd/chaincfg/chainhash"
-	"github.com/btcsuite/btcd/rpcclient"
-	"github.com/btcsuite/btcd/wire"
-	"github.com/go-errors/errors"
-	"github.com/lightningnetwork/lnd/lnrpc"
-	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
-	"github.com/lightningnetwork/lnd/lntest"
-	"github.com/lightningnetwork/lnd/lntest/wait"
-	"github.com/stretchr/testify/require"
-)
-
-var (
-	harnessNetParams = &chaincfg.RegressionNetParams
-
-	// lndExecutable is the full path to the lnd binary.
-	lndExecutable = flag.String(
-		"lndexec", itestLndBinary, "full path to lnd binary",
-	)
-
-	slowMineDelay = 20 * time.Millisecond
-)
-
-const (
-	testFeeBase         = 1e+6
-	defaultCSV          = lntest.DefaultCSV
-	defaultTimeout      = wait.DefaultTimeout
-	minerMempoolTimeout = wait.MinerMempoolTimeout
-	channelCloseTimeout = wait.ChannelCloseTimeout
-	itestLndBinary      = "../../lnd-itest"
-	anchorSize          = 330
-	noFeeLimitMsat      = math.MaxInt64
-
-	AddrTypeWitnessPubkeyHash = lnrpc.AddressType_WITNESS_PUBKEY_HASH
-	AddrTypeNestedPubkeyHash  = lnrpc.AddressType_NESTED_PUBKEY_HASH
-	AddrTypeTaprootPubkey     = lnrpc.AddressType_TAPROOT_PUBKEY
-)
-
-// harnessTest wraps a regular testing.T providing enhanced error detection
-// and propagation. All error will be augmented with a full stack-trace in
-// order to aid in debugging. Additionally, any panics caused by active
-// test cases will also be handled and represented as fatals.
-type harnessTest struct {
-	t *testing.T
-
-	// testCase is populated during test execution and represents the
-	// current test case.
-	testCase *testCase
-
-	// lndHarness is a reference to the current network harness. Will be
-	// nil if not yet set up.
-	lndHarness *lntest.NetworkHarness
-}
-
-// newHarnessTest creates a new instance of a harnessTest from a regular
-// testing.T instance.
-func newHarnessTest(t *testing.T, net *lntest.NetworkHarness) *harnessTest {
-	return &harnessTest{t, nil, net}
-}
-
-// Skipf calls the underlying testing.T's Skip method, causing the current test
-// to be skipped.
-func (h *harnessTest) Skipf(format string, args ...interface{}) {
-	h.t.Skipf(format, args...)
-}
-
-// Fatalf causes the current active test case to fail with a fatal error. All
-// integration tests should mark test failures solely with this method due to
-// the error stack traces it produces.
-func (h *harnessTest) Fatalf(format string, a ...interface{}) {
-	if h.lndHarness != nil {
-		h.lndHarness.SaveProfilesPages(h.t)
-	}
-
-	stacktrace := errors.Wrap(fmt.Sprintf(format, a...), 1).ErrorStack()
-
-	if h.testCase != nil {
-		h.t.Fatalf("Failed: (%v): exited with error: \n"+
-			"%v", h.testCase.name, stacktrace)
-	} else {
-		h.t.Fatalf("Error outside of test: %v", stacktrace)
-	}
-}
-
-// RunTestCase executes a harness test case. Any errors or panics will be
-// represented as fatal.
-func (h *harnessTest) RunTestCase(testCase *testCase) {
-	h.testCase = testCase
-	defer func() {
-		h.testCase = nil
-	}()
-
-	defer func() {
-		if err := recover(); err != nil {
-			description := errors.Wrap(err, 2).ErrorStack()
-			h.t.Fatalf("Failed: (%v) panicked with: \n%v",
-				h.testCase.name, description)
-		}
-	}()
-
-	testCase.test(h.lndHarness, h)
-}
-
-func (h *harnessTest) Logf(format string, args ...interface{}) {
-	h.t.Logf(format, args...)
-}
-
-func (h *harnessTest) Log(args ...interface{}) {
-	h.t.Log(args...)
-}
-
-func (h *harnessTest) getLndBinary() string {
-	binary := itestLndBinary
-	lndExec := ""
-	if lndExecutable != nil && *lndExecutable != "" {
-		lndExec = *lndExecutable
-	}
-	if lndExec == "" && runtime.GOOS == "windows" {
-		// Windows (even in a bash like environment like git bash as on
-		// Travis) doesn't seem to like relative paths to exe files...
-		currentDir, err := os.Getwd()
-		if err != nil {
-			h.Fatalf("unable to get working directory: %v", err)
-		}
-		targetPath := filepath.Join(currentDir, "../../lnd-itest.exe")
-		binary, err = filepath.Abs(targetPath)
-		if err != nil {
-			h.Fatalf("unable to get absolute path: %v", err)
-		}
-	} else if lndExec != "" {
-		binary = lndExec
-	}
-
-	return binary
-}
-
-type testCase struct {
-	name string
-	test func(net *lntest.NetworkHarness, t *harnessTest)
-}
-
-// waitForTxInMempool polls until finding one transaction in the provided
-// miner's mempool. An error is returned if *one* transaction isn't found within
-// the given timeout.
-func waitForTxInMempool(miner *rpcclient.Client,
-	timeout time.Duration) (*chainhash.Hash, error) {
-
-	txs, err := waitForNTxsInMempool(miner, 1, timeout)
-	if err != nil {
-		return nil, err
-	}
-
-	return txs[0], err
-}
-
-// waitForNTxsInMempool polls until finding the desired number of transactions
-// in the provided miner's mempool. An error is returned if this number is not
-// met after the given timeout.
-func waitForNTxsInMempool(miner *rpcclient.Client, n int,
-	timeout time.Duration) ([]*chainhash.Hash, error) {
-
-	breakTimeout := time.After(timeout)
-	ticker := time.NewTicker(50 * time.Millisecond)
-	defer ticker.Stop()
-
-	var err error
-	var mempool []*chainhash.Hash
-	for {
-		select {
-		case <-breakTimeout:
-			return nil, fmt.Errorf("wanted %v, found %v txs "+
-				"in mempool: %v", n, len(mempool), mempool)
-		case <-ticker.C:
-			mempool, err = miner.GetRawMempool()
-			if err != nil {
-				return nil, err
-			}
-
-			if len(mempool) == n {
-				return mempool, nil
-			}
-		}
-	}
-}
-
-// mineBlocks mine 'num' of blocks and check that blocks are present in
-// node blockchain. numTxs should be set to the number of transactions
-// (excluding the coinbase) we expect to be included in the first mined block.
-func mineBlocksFast(t *harnessTest, net *lntest.NetworkHarness,
-	num uint32, numTxs int) []*wire.MsgBlock {
-
-	// If we expect transactions to be included in the blocks we'll mine,
-	// we wait here until they are seen in the miner's mempool.
-	var txids []*chainhash.Hash
-	var err error
-	if numTxs > 0 {
-		txids, err = waitForNTxsInMempool(
-			net.Miner.Client, numTxs, minerMempoolTimeout,
-		)
-		if err != nil {
-			t.Fatalf("unable to find txns in mempool: %v", err)
-		}
-	}
-
-	blocks := make([]*wire.MsgBlock, num)
-
-	blockHashes, err := net.Miner.Client.Generate(num)
-	if err != nil {
-		t.Fatalf("unable to generate blocks: %v", err)
-	}
-
-	for i, blockHash := range blockHashes {
-		block, err := net.Miner.Client.GetBlock(blockHash)
-		if err != nil {
-			t.Fatalf("unable to get block: %v", err)
-		}
-
-		blocks[i] = block
-	}
-
-	// Finally, assert that all the transactions were included in the first
-	// block.
-	for _, txid := range txids {
-		assertTxInBlock(t, blocks[0], txid)
-	}
-
-	return blocks
-}
-
-// mineBlocksSlow mines 'num' of blocks and checks that blocks are present in
-// the mining node's blockchain. numTxs should be set to the number of
-// transactions (excluding the coinbase) we expect to be included in the first
-// mined block. Between each mined block an artificial delay is introduced to
-// give all network participants time to catch up.
-//
-// NOTE: This function currently is just an alias for mineBlocksSlow.
-func mineBlocks(t *harnessTest, net *lntest.NetworkHarness,
-	num uint32, numTxs int) []*wire.MsgBlock {
-
-	return mineBlocksSlow(t, net, num, numTxs)
-}
-
-// mineBlocksSlow mines 'num' of blocks and checks that blocks are present in
-// the mining node's blockchain. numTxs should be set to the number of
-// transactions (excluding the coinbase) we expect to be included in the first
-// mined block. Between each mined block an artificial delay is introduced to
-// give all network participants time to catch up.
-func mineBlocksSlow(t *harnessTest, net *lntest.NetworkHarness,
-	num uint32, numTxs int) []*wire.MsgBlock {
-
-	t.t.Helper()
-
-	// If we expect transactions to be included in the blocks we'll mine,
-	// we wait here until they are seen in the miner's mempool.
-	var txids []*chainhash.Hash
-	var err error
-	if numTxs > 0 {
-		txids, err = waitForNTxsInMempool(
-			net.Miner.Client, numTxs, minerMempoolTimeout,
-		)
-		require.NoError(t.t, err, "unable to find txns in mempool")
-	}
-
-	blocks := make([]*wire.MsgBlock, num)
-	blockHashes := make([]*chainhash.Hash, 0, num)
-
-	for i := uint32(0); i < num; i++ {
-		generatedHashes, err := net.Miner.Client.Generate(1)
-		require.NoError(t.t, err, "generate blocks")
-		blockHashes = append(blockHashes, generatedHashes...)
-
-		time.Sleep(slowMineDelay)
-	}
-
-	for i, blockHash := range blockHashes {
-		block, err := net.Miner.Client.GetBlock(blockHash)
-		require.NoError(t.t, err, "get blocks")
-
-		blocks[i] = block
-	}
-
-	// Finally, assert that all the transactions were included in the first
-	// block.
-	for _, txid := range txids {
-		assertTxInBlock(t, blocks[0], txid)
-	}
-
-	return blocks
-}
-
-func assertTxInBlock(t *harnessTest, block *wire.MsgBlock, txid *chainhash.Hash) {
-	for _, tx := range block.Transactions {
-		sha := tx.TxHash()
-		if bytes.Equal(txid[:], sha[:]) {
-			return
-		}
-	}
-
-	t.Fatalf("tx was not included in block")
-}
-
-func assertWalletUnspent(t *harnessTest, node *lntest.HarnessNode,
-	out *lnrpc.OutPoint, account string) {
-
-	t.t.Helper()
-
-	ctxb := context.Background()
-	err := wait.NoError(func() error {
-		ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
-		defer cancel()
-		unspent, err := node.WalletKitClient.ListUnspent(
-			ctxt, &walletrpc.ListUnspentRequest{
-				Account: account,
-			},
-		)
-		if err != nil {
-			return err
-		}
-
-		err = errors.New("tx with wanted txhash never found")
-		for _, utxo := range unspent.Utxos {
-			if !bytes.Equal(utxo.Outpoint.TxidBytes, out.TxidBytes) {
-				continue
-			}
-
-			err = errors.New("wanted output is not a wallet utxo")
-			if utxo.Outpoint.OutputIndex != out.OutputIndex {
-				continue
-			}
-
-			return nil
-		}
-
-		return err
-	}, defaultTimeout)
-	require.NoError(t.t, err)
-}

itest/utils.go

@@ -1,211 +1,42 @@
 package itest
 
 import (
-	"context"
-	"crypto/rand"
-	"fmt"
-	"io"
-	"time"
+	"flag"
+	"math"
 
 	"github.com/btcsuite/btcd/btcutil"
-	"github.com/btcsuite/btcd/rpcclient"
-	"github.com/btcsuite/btcd/wire"
-	"github.com/go-errors/errors"
+	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnrpc"
-	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
 	"github.com/lightningnetwork/lnd/lntemp"
-	"github.com/lightningnetwork/lnd/lntest"
+	"github.com/lightningnetwork/lnd/lntemp/node"
 	"github.com/lightningnetwork/lnd/lntest/wait"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/lnwire"
-	"github.com/stretchr/testify/require"
 )
 
-// completePaymentRequests sends payments from a lightning node to complete all
-// payment requests. If the awaitResponse parameter is true, this function
-// does not return until all payments successfully complete without errors.
-func completePaymentRequests(client lnrpc.LightningClient,
-	routerClient routerrpc.RouterClient, paymentRequests []string,
-	awaitResponse bool) error {
+const (
+	testFeeBase    = 1e+6
+	defaultCSV     = node.DefaultCSV
+	defaultTimeout = wait.DefaultTimeout
+	itestLndBinary = "../../lnd-itest"
+	anchorSize     = 330
+	noFeeLimitMsat = math.MaxInt64
 
-	ctxb := context.Background()
-	ctx, cancel := context.WithTimeout(ctxb, defaultTimeout)
-	defer cancel()
+	AddrTypeWitnessPubkeyHash = lnrpc.AddressType_WITNESS_PUBKEY_HASH
+	AddrTypeNestedPubkeyHash  = lnrpc.AddressType_NESTED_PUBKEY_HASH
+	AddrTypeTaprootPubkey     = lnrpc.AddressType_TAPROOT_PUBKEY
+)
 
-	// We start by getting the current state of the client's channels. This
-	// is needed to ensure the payments actually have been committed before
-	// we return.
-	req := &lnrpc.ListChannelsRequest{}
-	listResp, err := client.ListChannels(ctx, req)
-	if err != nil {
-		return err
-	}
+var (
+	harnessNetParams = &chaincfg.RegressionNetParams
 
-	// send sends a payment and returns an error if it doesn't succeeded.
-	send := func(payReq string) error {
-		ctxc, cancel := context.WithCancel(ctx)
-		defer cancel()
-
-		payStream, err := routerClient.SendPaymentV2(
-			ctxc,
-			&routerrpc.SendPaymentRequest{
-				PaymentRequest: payReq,
-				TimeoutSeconds: 60,
-				FeeLimitMsat:   noFeeLimitMsat,
-			},
-		)
-		if err != nil {
-			return err
-		}
-
-		resp, err := getPaymentResult(payStream)
-		if err != nil {
-			return err
-		}
-		if resp.Status != lnrpc.Payment_SUCCEEDED {
-			return errors.New(resp.FailureReason)
-		}
-
-		return nil
-	}
-
-	// Launch all payments simultaneously.
-	results := make(chan error)
-	for _, payReq := range paymentRequests {
-		go func(payReq string) {
-			err := send(payReq)
-			if awaitResponse {
-				results <- err
-			}
-		}(payReq)
-	}
-
-	// If awaiting a response, verify that all payments succeeded.
-	if awaitResponse {
-		for range paymentRequests {
-			err := <-results
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
-	// We are not waiting for feedback in the form of a response, but we
-	// should still wait long enough for the server to receive and handle
-	// the send before cancelling the request. We wait for the number of
-	// updates to one of our channels has increased before we return.
-	err = wait.Predicate(func() bool {
-		newListResp, err := client.ListChannels(ctx, req)
-		if err != nil {
-			return false
-		}
-
-		// If the number of open channels is now lower than before
-		// attempting the payments, it means one of the payments
-		// triggered a force closure (for example, due to an incorrect
-		// preimage). Return early since it's clear the payment was
-		// attempted.
-		if len(newListResp.Channels) < len(listResp.Channels) {
-			return true
-		}
-
-		for _, c1 := range listResp.Channels {
-			for _, c2 := range newListResp.Channels {
-				if c1.ChannelPoint != c2.ChannelPoint {
-					continue
-				}
-
-				// If this channel has an increased numbr of
-				// updates, we assume the payments are
-				// committed, and we can return.
-				if c2.NumUpdates > c1.NumUpdates {
-					return true
-				}
-			}
-		}
-
-		return false
-	}, defaultTimeout)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// makeFakePayHash creates random pre image hash.
-func makeFakePayHash(t *harnessTest) []byte {
-	randBuf := make([]byte, 32)
-
-	if _, err := rand.Read(randBuf); err != nil {
-		t.Fatalf("internal error, cannot generate random string: %v", err)
-	}
-
-	return randBuf
-}
-
-// createPayReqs is a helper method that will create a slice of payment
-// requests for the given node.
-func createPayReqs(node *lntest.HarnessNode, paymentAmt btcutil.Amount,
-	numInvoices int) ([]string, [][]byte, []*lnrpc.Invoice, error) {
-
-	payReqs := make([]string, numInvoices)
-	rHashes := make([][]byte, numInvoices)
-	invoices := make([]*lnrpc.Invoice, numInvoices)
-	for i := 0; i < numInvoices; i++ {
-		preimage := make([]byte, 32)
-		_, err := rand.Read(preimage)
-		if err != nil {
-			return nil, nil, nil, fmt.Errorf("unable to generate "+
-				"preimage: %v", err)
-		}
-		invoice := &lnrpc.Invoice{
-			Memo:      "testing",
-			RPreimage: preimage,
-			Value:     int64(paymentAmt),
-		}
-		ctxt, _ := context.WithTimeout(
-			context.Background(), defaultTimeout,
-		)
-		resp, err := node.AddInvoice(ctxt, invoice)
-		if err != nil {
-			return nil, nil, nil, fmt.Errorf("unable to add "+
-				"invoice: %v", err)
-		}
-
-		// Set the payment address in the invoice so the caller can
-		// properly use it.
-		invoice.PaymentAddr = resp.PaymentAddr
-
-		payReqs[i] = resp.PaymentRequest
-		rHashes[i] = resp.RHash
-		invoices[i] = invoice
-	}
-	return payReqs, rHashes, invoices, nil
-}
-
-// getChanInfo is a helper method for getting channel info for a node's sole
-// channel.
-func getChanInfo(node *lntest.HarnessNode) (*lnrpc.Channel, error) {
-	ctxb := context.Background()
-	ctx, cancel := context.WithTimeout(ctxb, defaultTimeout)
-	defer cancel()
-
-	req := &lnrpc.ListChannelsRequest{}
-	channelInfo, err := node.ListChannels(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-	if len(channelInfo.Channels) != 1 {
-		return nil, fmt.Errorf("node should only have a single "+
-			"channel, instead it has %v", len(channelInfo.Channels))
-	}
-
-	return channelInfo.Channels[0], nil
-}
+	// lndExecutable is the full path to the lnd binary.
+	lndExecutable = flag.String(
+		"lndexec", itestLndBinary, "full path to lnd binary",
+	)
+)
 
 // commitTypeHasAnchors returns whether commitType uses anchor outputs.
 func commitTypeHasAnchors(commitType lnrpc.CommitmentType) bool {
@@ -247,8 +78,9 @@ func calcStaticFee(c lnrpc.CommitmentType, numHTLCs int) btcutil.Amount {
 		feePerKw = chainfee.SatPerKWeight(
 			lntemp.DefaultFeeRateSatPerKw,
 		)
-		commitWeight = input.CommitWeight
-		anchors      = btcutil.Amount(0)
+		commitWeight       = input.CommitWeight
+		anchors            = btcutil.Amount(0)
+		defaultSatPerVByte = lnwallet.DefaultAnchorsCommitMaxFeeRateSatPerVByte
 	)
 
 	// The anchor commitment type is slightly heavier, and we must also add
@@ -257,8 +89,7 @@ func calcStaticFee(c lnrpc.CommitmentType, numHTLCs int) btcutil.Amount {
 	// channels.
 	if commitTypeHasAnchors(c) {
 		feePerKw = chainfee.SatPerKVByte(
-			lnwallet.DefaultAnchorsCommitMaxFeeRateSatPerVByte * 1000,
-		).FeePerKWeight()
+			defaultSatPerVByte * 1000).FeePerKWeight()
 		commitWeight = input.AnchorCommitWeight
 		anchors = 2 * anchorSize
 	}
@@ -267,29 +98,6 @@ func calcStaticFee(c lnrpc.CommitmentType, numHTLCs int) btcutil.Amount {
 		anchors
 }
 
-// channelCommitType retrieves the active channel commitment type for the given
-// chan point.
-func channelCommitType(node *lntest.HarnessNode,
-	chanPoint *lnrpc.ChannelPoint) (lnrpc.CommitmentType, error) {
-
-	ctxb := context.Background()
-	ctxt, _ := context.WithTimeout(ctxb, defaultTimeout)
-
-	req := &lnrpc.ListChannelsRequest{}
-	channels, err := node.ListChannels(ctxt, req)
-	if err != nil {
-		return 0, fmt.Errorf("listchannels failed: %v", err)
-	}
-
-	for _, c := range channels.Channels {
-		if c.ChannelPoint == txStr(chanPoint) {
-			return c.CommitmentType, nil
-		}
-	}
-
-	return 0, fmt.Errorf("channel point %v not found", chanPoint)
-}
-
 // calculateMaxHtlc re-implements the RequiredRemoteChannelReserve of the
 // funding manager's config, which corresponds to the maximum MaxHTLC value we
 // allow users to set when updating a channel policy.
@@ -298,171 +106,3 @@ func calculateMaxHtlc(chanCap btcutil.Amount) uint64 {
 	max := lnwire.NewMSatFromSatoshis(chanCap) - reserve
 	return uint64(max)
 }
-
-// waitForNodeBlockHeight queries the node for its current block height until
-// it reaches the passed height.
-func waitForNodeBlockHeight(node *lntest.HarnessNode, height int32) error {
-	ctxb := context.Background()
-	ctx, cancel := context.WithTimeout(ctxb, defaultTimeout)
-	defer cancel()
-
-	var predErr error
-	err := wait.Predicate(func() bool {
-		info, err := node.GetInfo(ctx, &lnrpc.GetInfoRequest{})
-		if err != nil {
-			predErr = err
-			return false
-		}
-
-		if int32(info.BlockHeight) != height {
-			predErr = fmt.Errorf("expected block height to "+
-				"be %v, was %v", height, info.BlockHeight)
-			return false
-		}
-		return true
-	}, defaultTimeout)
-	if err != nil {
-		return predErr
-	}
-	return nil
-}
-
-// getNTxsFromMempool polls until finding the desired number of transactions in
-// the provided miner's mempool and returns the full transactions to the caller.
-func getNTxsFromMempool(miner *rpcclient.Client, n int,
-	timeout time.Duration) ([]*wire.MsgTx, error) {
-
-	txids, err := waitForNTxsInMempool(miner, n, timeout)
-	if err != nil {
-		return nil, err
-	}
-
-	var txes []*wire.MsgTx
-	for _, txid := range txids {
-		tx, err := miner.GetRawTransaction(txid)
-		if err != nil {
-			return nil, err
-		}
-		txes = append(txes, tx.MsgTx())
-	}
-	return txes, nil
-}
-
-// getTxFee retrieves parent transactions and reconstructs the fee paid.
-func getTxFee(miner *rpcclient.Client, tx *wire.MsgTx) (btcutil.Amount, error) {
-	var balance btcutil.Amount
-	for _, in := range tx.TxIn {
-		parentHash := in.PreviousOutPoint.Hash
-		rawTx, err := miner.GetRawTransaction(&parentHash)
-		if err != nil {
-			return 0, err
-		}
-		parent := rawTx.MsgTx()
-		balance += btcutil.Amount(
-			parent.TxOut[in.PreviousOutPoint.Index].Value,
-		)
-	}
-
-	for _, out := range tx.TxOut {
-		balance -= btcutil.Amount(out.Value)
-	}
-
-	return balance, nil
-}
-
-// channelSubscription houses the proxied update and error chans for a node's
-// channel subscriptions.
-type channelSubscription struct {
-	updateChan chan *lnrpc.ChannelEventUpdate
-	errChan    chan error
-	quit       chan struct{}
-}
-
-// subscribeChannelNotifications subscribes to channel updates and launches a
-// goroutine that forwards these to the returned channel.
-func subscribeChannelNotifications(ctxb context.Context, t *harnessTest,
-	node *lntest.HarnessNode) channelSubscription {
-
-	// We'll first start by establishing a notification client which will
-	// send us notifications upon channels becoming active, inactive or
-	// closed.
-	req := &lnrpc.ChannelEventSubscription{}
-	ctx, cancelFunc := context.WithCancel(ctxb)
-
-	chanUpdateClient, err := node.SubscribeChannelEvents(ctx, req)
-	if err != nil {
-		t.Fatalf("unable to create channel update client: %v", err)
-	}
-
-	// We'll launch a goroutine that will be responsible for proxying all
-	// notifications recv'd from the client into the channel below.
-	errChan := make(chan error, 1)
-	quit := make(chan struct{})
-	chanUpdates := make(chan *lnrpc.ChannelEventUpdate, 20)
-	go func() {
-		defer cancelFunc()
-
-		for {
-			select {
-			case <-quit:
-				return
-			default:
-				chanUpdate, err := chanUpdateClient.Recv()
-				select {
-				case <-quit:
-					return
-				default:
-				}
-
-				if err == io.EOF {
-					return
-				} else if err != nil {
-					select {
-					case errChan <- err:
-					case <-quit:
-					}
-					return
-				}
-
-				select {
-				case chanUpdates <- chanUpdate:
-				case <-quit:
-					return
-				}
-			}
-		}
-	}()
-
-	return channelSubscription{
-		updateChan: chanUpdates,
-		errChan:    errChan,
-		quit:       quit,
-	}
-}
-
-// findTxAtHeight gets all of the transactions that a node's wallet has a record
-// of at the target height, and finds and returns the tx with the target txid,
-// failing if it is not found.
-func findTxAtHeight(t *harnessTest, height int32,
-	target string, node *lntest.HarnessNode) *lnrpc.Transaction {
-
-	ctxb := context.Background()
-	ctx, cancel := context.WithTimeout(ctxb, defaultTimeout)
-	defer cancel()
-
-	txns, err := node.LightningClient.GetTransactions(
-		ctx, &lnrpc.GetTransactionsRequest{
-			StartHeight: height,
-			EndHeight:   height,
-		},
-	)
-	require.NoError(t.t, err, "could not get transactions")
-
-	for _, tx := range txns.Transactions {
-		if tx.TxHash == target {
-			return tx
-		}
-	}
-
-	return nil
-}