itest: remove the use of standby nodes

This commit removes the usage of the standby nodes and uses
`CreateSimpleNetwork` when applicable. Also introduces a helper method
`NewNodeWithCoins` to quickly start a node with funds.

itest/lnd_channel_backup_test.go

@@ -844,7 +844,7 @@ func runChanRestoreScenarioForceClose(ht *lntest.HarnessTest, zeroConf bool) {
 // and the on-disk channel.backup are updated each time a channel is
 // opened/closed.
 func testChannelBackupUpdates(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 
 	// First, we'll make a temp directory that we'll use to store our
 	// backup file, so we can check in on it during the test easily.
@@ -1052,7 +1052,7 @@ func testExportChannelBackup(ht *lntest.HarnessTest) {
 
 	// With Carol up, we'll now connect her to Alice, and open a channel
 	// between them.
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.ConnectNodes(carol, alice)
 
 	// Next, we'll open two channels between Alice and Carol back to back.

itest/lnd_channel_balance_test.go

@@ -48,7 +48,8 @@ func testChannelBalance(ht *lntest.HarnessTest) {
 	}
 
 	// Before beginning, make sure alice and bob are connected.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
 	ht.EnsureConnected(alice, bob)
 
 	chanPoint := ht.OpenChannel(
@@ -118,7 +119,7 @@ func testChannelUnsettledBalance(ht *lntest.HarnessTest) {
 	carol := ht.NewNode("Carol", []string{"--hodl.exit-settle"})
 
 	// Connect Alice to Carol.
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.ConnectNodes(alice, carol)
 
 	// Open a channel between Alice and Carol.

itest/lnd_channel_force_close_test.go

@@ -771,7 +771,7 @@ func testFailingChannel(ht *lntest.HarnessTest) {
 	// totally unrelated preimage.
 	carol := ht.NewNode("Carol", []string{"--hodl.bogus-settle"})
 
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.ConnectNodes(alice, carol)
 
 	// Let Alice connect and open a channel to Carol,

itest/lnd_channel_graph_test.go

@@ -218,7 +218,9 @@ func testUpdateChanStatus(ht *lntest.HarnessTest) {
 // describeGraph RPC request unless explicitly asked for.
 func testUnannouncedChannels(ht *lntest.HarnessTest) {
 	amount := funding.MaxBtcFundingAmount
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Open a channel between Alice and Bob, ensuring the
 	// channel has been opened properly.
@@ -267,14 +269,10 @@ func testGraphTopologyNtfns(ht *lntest.HarnessTest, pinned bool) {
 
 	// Spin up Bob first, since we will need to grab his pubkey when
 	// starting Alice to test pinned syncing.
-	bob := ht.Bob
+	bob := ht.NewNodeWithCoins("Bob", nil)
 	bobInfo := bob.RPC.GetInfo()
 	bobPubkey := bobInfo.IdentityPubkey
 
-	// Restart Bob as he may have leftover announcements from previous
-	// tests, causing the graph to be unsynced.
-	ht.RestartNodeWithExtraArgs(bob, nil)
-
 	// For unpinned syncing, start Alice as usual. Otherwise grab Bob's
 	// pubkey to include in his pinned syncer set.
 	var aliceArgs []string
@@ -285,8 +283,7 @@ func testGraphTopologyNtfns(ht *lntest.HarnessTest, pinned bool) {
 		}
 	}
 
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", aliceArgs)
-	ht.RestartNodeWithExtraArgs(alice, aliceArgs)
 
 	// Connect Alice and Bob.
 	ht.EnsureConnected(alice, bob)
@@ -379,7 +376,9 @@ func testGraphTopologyNtfns(ht *lntest.HarnessTest, pinned bool) {
 // external IP addresses specified on the command line, that those addresses
 // announced to the network and reported in the network graph.
 func testNodeAnnouncement(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNode("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	advertisedAddrs := []string{
 		"192.168.1.1:8333",
@@ -434,7 +433,9 @@ func testNodeAnnouncement(ht *lntest.HarnessTest) {
 // the requests correctly and that the new node announcement is broadcast
 // with the right information after updating our node.
 func testUpdateNodeAnnouncement(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNode("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	var lndArgs []string
 

itest/lnd_channel_policy_test.go

@@ -30,19 +30,16 @@ func testUpdateChannelPolicy(ht *lntest.HarnessTest) {
 	chanAmt := funding.MaxBtcFundingAmount
 	pushAmt := chanAmt / 2
 
-	alice, bob := ht.Alice, ht.Bob
-
 	// Create a channel Alice->Bob.
-	chanPoint := ht.OpenChannel(
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-		alice, bob, lntest.OpenChannelParams{
+		[][]string{nil, nil}, lntest.OpenChannelParams{
 			Amt:     chanAmt,
 			PushAmt: pushAmt,
 		},
 	)
 
-	// We add all the nodes' update channels to a slice, such that we can
+	alice, bob := nodes[0], nodes[1]
-	// make sure they all receive the expected updates.
+	chanPoint := chanPoints[0]
-	nodes := []*node.HarnessNode{alice, bob}
 
 	// Alice and Bob should see each other's ChannelUpdates, advertising the
 	// default routing policies. We do not currently set any inbound fees.
@@ -441,7 +438,8 @@ func testUpdateChannelPolicy(ht *lntest.HarnessTest) {
 func testSendUpdateDisableChannel(ht *lntest.HarnessTest) {
 	const chanAmt = 100000
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
 
 	// Create a new node Eve, which will be restarted later with a config
 	// that has an inactive channel timeout of just 6 seconds (down from
@@ -678,7 +676,9 @@ func testUpdateChannelPolicyForPrivateChannel(ht *lntest.HarnessTest) {
 
 	// We'll create the following topology first,
 	// Alice <--public:100k--> Bob <--private:100k--> Carol
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Open a channel with 100k satoshis between Alice and Bob.
 	chanPointAliceBob := ht.OpenChannel(
@@ -787,16 +787,14 @@ func testUpdateChannelPolicyFeeRateAccuracy(ht *lntest.HarnessTest) {
 	pushAmt := chanAmt / 2
 
 	// Create a channel Alice -> Bob.
-	alice, bob := ht.Alice, ht.Bob
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	chanPoint := ht.OpenChannel(
+		[][]string{nil, nil}, lntest.OpenChannelParams{
-		alice, bob, lntest.OpenChannelParams{
 			Amt:     chanAmt,
 			PushAmt: pushAmt,
 		},
 	)
-
+	alice := nodes[0]
-	// Nodes that we need to make sure receive the channel updates.
+	chanPoint := chanPoints[0]
-	nodes := []*node.HarnessNode{alice, bob}
 
 	baseFee := int64(1500)
 	timeLockDelta := uint32(66)

itest/lnd_coop_close_external_delivery_test.go

@@ -58,7 +58,8 @@ func testCoopCloseWithExternalDelivery(ht *lntest.HarnessTest) {
 func testCoopCloseWithExternalDeliveryImpl(ht *lntest.HarnessTest,
 	upfrontShutdown bool, deliveryAddressType lnrpc.AddressType) {
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("bob", nil)
 	ht.ConnectNodes(alice, bob)
 
 	// Here we generate a final delivery address in bob's wallet but set by

itest/lnd_coop_close_with_htlcs_test.go

@@ -37,7 +37,8 @@ func testCoopCloseWithHtlcs(ht *lntest.HarnessTest) {
 // channel party initiates a channel shutdown while an HTLC is still pending on
 // the channel.
 func coopCloseWithHTLCs(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("bob", nil)
 	ht.ConnectNodes(alice, bob)
 
 	// Here we set up a channel between Alice and Bob, beginning with a
@@ -128,7 +129,8 @@ func coopCloseWithHTLCs(ht *lntest.HarnessTest) {
 // process continues as expected even if a channel re-establish happens after
 // one party has already initiated the shutdown.
 func coopCloseWithHTLCsWithRestart(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("bob", nil)
 	ht.ConnectNodes(alice, bob)
 
 	// Open a channel between Alice and Bob with the balance split equally.

itest/lnd_custom_features.go

@@ -13,8 +13,6 @@ import (
 // sets. For completeness, it also asserts that features aren't set in places
 // where they aren't intended to be.
 func testCustomFeatures(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
-
 	var (
 		// Odd custom features so that we don't need to worry about
 		// issues connecting to peers.
@@ -29,14 +27,13 @@ func testCustomFeatures(ht *lntest.HarnessTest) {
 		fmt.Sprintf("--protocol.custom-nodeann=%v", customNodeAnn),
 		fmt.Sprintf("--protocol.custom-invoice=%v", customInvoice),
 	}
-	ht.RestartNodeWithExtraArgs(alice, extraArgs)
+	cfgs := [][]string{extraArgs, nil}
 
-	// Connect nodes and open a channel so that Alice will be included
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	// in Bob's graph.
+		cfgs, lntest.OpenChannelParams{Amt: 1000000},
-	ht.ConnectNodes(alice, bob)
-	chanPoint := ht.OpenChannel(
-		alice, bob, lntest.OpenChannelParams{Amt: 1000000},
 	)
+	alice, bob := nodes[0], nodes[1]
+	chanPoint := chanPoints[0]
 
 	// Check that Alice's custom feature bit was sent to Bob in her init
 	// message.

itest/lnd_custom_message_test.go

@@ -14,8 +14,6 @@ import (
 // types (within the message type range usually reserved for protocol messages)
 // via the send and subscribe custom message APIs.
 func testCustomMessage(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
-
 	var (
 		overrideType1  uint32 = 554
 		overrideType2  uint32 = 555
@@ -27,7 +25,8 @@ func testCustomMessage(ht *lntest.HarnessTest) {
 	extraArgs := []string{
 		fmt.Sprintf(msgOverrideArg, overrideType1),
 	}
-	ht.RestartNodeWithExtraArgs(alice, extraArgs)
+	alice := ht.NewNode("Alice", extraArgs)
+	bob := ht.NewNode("Bob", nil)
 
 	// Subscribe Alice to custom messages before we send any, so that we
 	// don't miss any.

itest/lnd_experimental_endorsement.go

@@ -24,7 +24,8 @@ func testExperimentalEndorsement(ht *lntest.HarnessTest) {
 // testEndorsement sets up a 5 hop network and tests propagation of
 // experimental endorsement signals.
 func testEndorsement(ht *lntest.HarnessTest, aliceEndorse bool) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 	carol := ht.NewNode(
 		"carol", []string{"--protocol.no-experimental-endorsement"},
 	)

itest/lnd_forward_interceptor_test.go

@@ -765,7 +765,9 @@ type interceptorTestScenario struct {
 func newInterceptorTestScenario(
 	ht *lntest.HarnessTest) *interceptorTestScenario {
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("bob", nil)
+
 	carol := ht.NewNode("carol", nil)
 	dave := ht.NewNode("dave", nil)
 

itest/lnd_funding_test.go

@@ -282,8 +282,7 @@ func testUnconfirmedChannelFunding(ht *lntest.HarnessTest) {
 
 	// We'll start off by creating a node for Carol.
 	carol := ht.NewNode("Carol", nil)
-
+	alice := ht.NewNode("Alice", nil)
-	alice := ht.Alice
 
 	// We'll send her some unconfirmed funds.
 	ht.FundCoinsUnconfirmed(2*chanAmt, carol)
@@ -402,7 +401,7 @@ func testUnconfirmedChannelFunding(ht *lntest.HarnessTest) {
 // testChannelFundingInputTypes tests that any type of supported input type can
 // be used to fund channels.
 func testChannelFundingInputTypes(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// We'll start off by creating a node for Carol.
 	carol := ht.NewNode("Carol", nil)
@@ -841,7 +840,7 @@ func testChannelFundingPersistence(ht *lntest.HarnessTest) {
 	}
 	carol := ht.NewNode("Carol", carolArgs)
 
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.ConnectNodes(alice, carol)
 
 	// Create a new channel that requires 5 confs before it's considered
@@ -957,8 +956,8 @@ func testBatchChanFunding(ht *lntest.HarnessTest) {
 	}
 	eve := ht.NewNode("eve", scidAliasArgs)
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", scidAliasArgs)
-	ht.RestartNodeWithExtraArgs(alice, scidAliasArgs)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// Before we start the test, we'll ensure Alice is connected to Carol
 	// and Dave, so she can open channels to both of them (and Bob).

itest/lnd_hold_invoice_force_test.go

@@ -17,10 +17,11 @@ import (
 // would otherwise trigger force closes when they expire.
 func testHoldInvoiceForceClose(ht *lntest.HarnessTest) {
 	// Open a channel between alice and bob.
-	alice, bob := ht.Alice, ht.Bob
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	chanPoint := ht.OpenChannel(
+		[][]string{nil, nil}, lntest.OpenChannelParams{Amt: 300000},
-		alice, bob, lntest.OpenChannelParams{Amt: 300000},
 	)
+	alice, bob := nodes[0], nodes[1]
+	chanPoint := chanPoints[0]
 
 	// Create a non-dust hold invoice for bob.
 	var (

itest/lnd_hold_persistence_test.go

@@ -28,7 +28,9 @@ func testHoldInvoicePersistence(ht *lntest.HarnessTest) {
 	carol := ht.NewNode("Carol", nil)
 
 	// Connect Alice to Carol.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 	ht.ConnectNodes(alice, carol)
 
 	// Open a channel between Alice and Carol which is private so that we

itest/lnd_htlc_test.go

@@ -14,7 +14,7 @@ import (
 func testLookupHtlcResolution(ht *lntest.HarnessTest) {
 	const chanAmt = btcutil.Amount(1000000)
 
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	carol := ht.NewNode("Carol", []string{
 		"--store-final-htlc-resolutions",
 	})

itest/lnd_invoice_acceptor_test.go

@@ -251,7 +251,8 @@ type acceptorTestScenario struct {
 //
 // Among them, Alice and Bob are standby nodes and Carol is a new node.
 func newAcceptorTestScenario(ht *lntest.HarnessTest) *acceptorTestScenario {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("bob", nil)
 	carol := ht.NewNode("carol", nil)
 
 	ht.EnsureConnected(alice, bob)

itest/lnd_macaroons_test.go

@@ -29,7 +29,7 @@ func testMacaroonAuthentication(ht *lntest.HarnessTest) {
 		newAddrReq = &lnrpc.NewAddressRequest{
 			Type: AddrTypeWitnessPubkeyHash,
 		}
-		testNode   = ht.Alice
+		testNode   = ht.NewNode("Alice", nil)
 		testClient = testNode.RPC.LN
 	)
 
@@ -295,7 +295,7 @@ func testMacaroonAuthentication(ht *lntest.HarnessTest) {
 // in the request must be set correctly, and the baked macaroon has the intended
 // permissions.
 func testBakeMacaroon(ht *lntest.HarnessTest) {
-	var testNode = ht.Alice
+	var testNode = ht.NewNode("Alice", nil)
 
 	testCases := []struct {
 		name string
@@ -521,7 +521,7 @@ func testBakeMacaroon(ht *lntest.HarnessTest) {
 func testDeleteMacaroonID(ht *lntest.HarnessTest) {
 	var (
 		ctxb     = ht.Context()
-		testNode = ht.Alice
+		testNode = ht.NewNode("Alice", nil)
 	)
 	ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
 	defer cancel()

itest/lnd_max_htlcs_test.go

@@ -19,25 +19,21 @@ func testMaxHtlcPathfind(ht *lntest.HarnessTest) {
 	// Bob to add a maximum of 5 htlcs to her commitment.
 	maxHtlcs := 5
 
-	alice, bob := ht.Alice, ht.Bob
+	// Create nodes with the new flag so they understand the new payment
-
-	// Restart nodes with the new flag so they understand the new payment
 	// status.
-	ht.RestartNodeWithExtraArgs(alice, []string{
+	cfg := []string{"--routerrpc.usestatusinitiated"}
-		"--routerrpc.usestatusinitiated",
+	cfgs := [][]string{cfg, cfg}
-	})
-	ht.RestartNodeWithExtraArgs(bob, []string{
-		"--routerrpc.usestatusinitiated",
-	})
 
-	ht.EnsureConnected(alice, bob)
+	// Create a channel Alice->Bob.
-	chanPoint := ht.OpenChannel(
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-		alice, bob, lntest.OpenChannelParams{
+		cfgs, lntest.OpenChannelParams{
 			Amt:            1000000,
 			PushAmt:        800000,
 			RemoteMaxHtlcs: uint16(maxHtlcs),
 		},
 	)
+	chanPoint := chanPoints[0]
+	alice, bob := nodes[0], nodes[1]
 
 	// Alice and bob should have one channel open with each other now.
 	ht.AssertNodeNumChannels(alice, 1)

itest/lnd_misc_test.go

@@ -39,9 +39,8 @@ func testDisconnectingTargetPeer(ht *lntest.HarnessTest) {
 		"--maxbackoff=1m",
 	}
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", args)
-	ht.RestartNodeWithExtraArgs(alice, args)
+	bob := ht.NewNodeWithCoins("Bob", args)
-	ht.RestartNodeWithExtraArgs(bob, args)
 
 	// Start by connecting Alice and Bob with no channels.
 	ht.EnsureConnected(alice, bob)
@@ -239,17 +238,11 @@ func testListChannels(ht *lntest.HarnessTest) {
 	const aliceRemoteMaxHtlcs = 50
 	const bobRemoteMaxHtlcs = 100
 
-	// Get the standby nodes and open a channel between them.
-	alice, bob := ht.Alice, ht.Bob
-
 	args := []string{fmt.Sprintf(
 		"--default-remote-max-htlcs=%v",
 		bobRemoteMaxHtlcs,
 	)}
-	ht.RestartNodeWithExtraArgs(bob, args)
+	cfgs := [][]string{nil, args}
-
-	// Connect Alice to Bob.
-	ht.EnsureConnected(alice, bob)
 
 	// Open a channel with 100k satoshis between Alice and Bob with Alice
 	// being the sole funder of the channel. The minial HTLC amount is set
@@ -264,8 +257,10 @@ func testListChannels(ht *lntest.HarnessTest) {
 		MinHtlc:        customizedMinHtlc,
 		RemoteMaxHtlcs: aliceRemoteMaxHtlcs,
 	}
-	chanPoint := ht.OpenChannel(alice, bob, p)
+
-	defer ht.CloseChannel(alice, chanPoint)
+	chanPoints, nodes := ht.CreateSimpleNetwork(cfgs, p)
+	alice, bob := nodes[0], nodes[1]
+	chanPoint := chanPoints[0]
 
 	// Alice should have one channel opened with Bob.
 	ht.AssertNodeNumChannels(alice, 1)
@@ -369,7 +364,7 @@ func testMaxPendingChannels(ht *lntest.HarnessTest) {
 	}
 	carol := ht.NewNode("Carol", args)
 
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.ConnectNodes(alice, carol)
 
 	carolBalance := btcutil.Amount(maxPendingChannels) * amount
@@ -439,7 +434,9 @@ func testMaxPendingChannels(ht *lntest.HarnessTest) {
 func testGarbageCollectLinkNodes(ht *lntest.HarnessTest) {
 	const chanAmt = 1000000
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Open a channel between Alice and Bob which will later be
 	// cooperatively closed.
@@ -553,7 +550,8 @@ func testRejectHTLC(ht *lntest.HarnessTest) {
 	// Alice ------> Carol ------> Bob
 	//
 	const chanAmt = btcutil.Amount(1000000)
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// Create Carol with reject htlc flag.
 	carol := ht.NewNode("Carol", []string{"--rejecthtlc"})
@@ -649,15 +647,16 @@ func testRejectHTLC(ht *lntest.HarnessTest) {
 func testNodeSignVerify(ht *lntest.HarnessTest) {
 	chanAmt := funding.MaxBtcFundingAmount
 	pushAmt := btcutil.Amount(100000)
-	alice, bob := ht.Alice, ht.Bob
+	p := lntest.OpenChannelParams{
+		Amt:     chanAmt,
+		PushAmt: pushAmt,
+	}
 
 	// Create a channel between alice and bob.
-	aliceBobCh := ht.OpenChannel(
+	cfgs := [][]string{nil, nil}
-		alice, bob, lntest.OpenChannelParams{
+	chanPoints, nodes := ht.CreateSimpleNetwork(cfgs, p)
-			Amt:     chanAmt,
+	alice, bob := nodes[0], nodes[1]
-			PushAmt: pushAmt,
+	aliceBobCh := chanPoints[0]
-		},
-	)
 
 	// alice signs "alice msg" and sends her signature to bob.
 	aliceMsg := []byte("alice msg")
@@ -694,14 +693,17 @@ func testNodeSignVerify(ht *lntest.HarnessTest) {
 // and not in one of the pending closure states. It also verifies that the
 // abandoned channel is reported as closed with close type 'abandoned'.
 func testAbandonChannel(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
-
 	// First establish a channel between Alice and Bob.
 	channelParam := lntest.OpenChannelParams{
 		Amt:     funding.MaxBtcFundingAmount,
 		PushAmt: btcutil.Amount(100000),
 	}
-	chanPoint := ht.OpenChannel(alice, bob, channelParam)
+
+	// Create a channel between alice and bob.
+	cfgs := [][]string{nil, nil}
+	chanPoints, nodes := ht.CreateSimpleNetwork(cfgs, channelParam)
+	alice, bob := nodes[0], nodes[1]
+	chanPoint := chanPoints[0]
 
 	// Now that the channel is open, we'll obtain its channel ID real quick
 	// so we can use it to query the graph below.
@@ -763,7 +765,7 @@ func testAbandonChannel(ht *lntest.HarnessTest) {
 // testSendAllCoins tests that we're able to properly sweep all coins from the
 // wallet into a single target address at the specified fee rate.
 func testSendAllCoins(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 
 	// First, we'll make a new node, Ainz who'll we'll use to test wallet
 	// sweeping.
@@ -1162,7 +1164,8 @@ func assertChannelConstraintsEqual(ht *lntest.HarnessTest,
 // on a message with a provided address.
 func testSignVerifyMessageWithAddr(ht *lntest.HarnessTest) {
 	// Using different nodes to sign the message and verify the signature.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNode("Alice,", nil)
+	bob := ht.NewNode("Bob,", nil)
 
 	// Test an lnd wallet created P2WKH address.
 	respAddr := alice.RPC.NewAddress(&lnrpc.NewAddressRequest{
@@ -1279,7 +1282,7 @@ func testSignVerifyMessageWithAddr(ht *lntest.HarnessTest) {
 // up with native SQL enabled, as we don't currently support migration of KV
 // invoices to the new SQL schema.
 func testNativeSQLNoMigration(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// Make sure we run the test with SQLite or Postgres.
 	if alice.Cfg.DBBackend != node.BackendSqlite &&

itest/lnd_mpp_test.go

@@ -180,8 +180,8 @@ type mppTestScenario struct {
 //	    \              /
 //	     \__ Dave ____/
 func newMppTestScenario(ht *lntest.HarnessTest) *mppTestScenario {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
-	ht.RestartNodeWithExtraArgs(bob, []string{
+	bob := ht.NewNodeWithCoins("Bob", []string{
 		"--maxpendingchannels=2",
 		"--accept-amp",
 	})

itest/lnd_multi-hop-error-propagation_test.go

@@ -15,7 +15,9 @@ func testHtlcErrorPropagation(ht *lntest.HarnessTest) {
 	// multi-hop payment.
 	const chanAmt = funding.MaxBtcFundingAmount
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Since we'd like to test some multi-hop failure scenarios, we'll
 	// introduce another node into our test network: Carol.

itest/lnd_multi-hop-payments_test.go

@@ -18,7 +18,8 @@ func testMultiHopPayments(ht *lntest.HarnessTest) {
 	// channel with Alice, and Carol with Dave. After this setup, the
 	// network topology should now look like:
 	//     Carol -> Dave -> Alice -> Bob
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
 
 	daveArgs := []string{"--protocol.legacy.onion"}
 	dave := ht.NewNode("Dave", daveArgs)
@@ -37,6 +38,7 @@ func testMultiHopPayments(ht *lntest.HarnessTest) {
 	ht.AssertHtlcEventType(daveEvents, routerrpc.HtlcEvent_UNKNOWN)
 
 	// Connect the nodes.
+	ht.ConnectNodes(alice, bob)
 	ht.ConnectNodes(dave, alice)
 	ht.ConnectNodes(carol, dave)
 

itest/lnd_network_test.go

@@ -126,7 +126,7 @@ func testReconnectAfterIPChange(ht *lntest.HarnessTest) {
 	}
 
 	// Connect Alice to Dave and Charlie.
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.ConnectNodes(alice, dave)
 	ht.ConnectNodes(alice, charlie)
 
@@ -218,7 +218,7 @@ func testReconnectAfterIPChange(ht *lntest.HarnessTest) {
 // testAddPeerConfig tests that the "--addpeer" config flag successfully adds
 // a new peer.
 func testAddPeerConfig(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 	info := alice.RPC.GetInfo()
 
 	alicePeerAddress := info.Uris[0]

itest/lnd_neutrino_test.go

@@ -13,7 +13,7 @@ func testNeutrino(ht *lntest.HarnessTest) {
 		ht.Skipf("skipping test for non neutrino backends")
 	}
 
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// Check if the neutrino sub server is running.
 	statusRes := alice.RPC.Status(nil)

itest/lnd_onchain_test.go

@@ -33,7 +33,7 @@ func testChainKit(ht *lntest.HarnessTest) {
 // testChainKitGetBlock ensures that given a block hash, the RPC endpoint
 // returns the correct target block.
 func testChainKitGetBlock(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// Get best block hash.
 	bestBlockRes := alice.RPC.GetBestBlock(nil)
@@ -63,7 +63,7 @@ func testChainKitGetBlock(ht *lntest.HarnessTest) {
 // testChainKitGetBlockHeader ensures that given a block hash, the RPC endpoint
 // returns the correct target block header.
 func testChainKitGetBlockHeader(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// Get best block hash.
 	bestBlockRes := alice.RPC.GetBestBlock(nil)
@@ -108,7 +108,7 @@ func testChainKitGetBlockHeader(ht *lntest.HarnessTest) {
 // testChainKitGetBlockHash ensures that given a block height, the RPC endpoint
 // returns the correct target block hash.
 func testChainKitGetBlockHash(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// Get best block hash.
 	bestBlockRes := alice.RPC.GetBestBlock(nil)
@@ -134,8 +134,7 @@ func testChainKitSendOutputsAnchorReserve(ht *lntest.HarnessTest) {
 	// NOTE: we cannot reuse the standby node here as the test requires the
 	// node to start with no UTXOs.
 	charlie := ht.NewNode("Charlie", args)
-	bob := ht.Bob
+	bob := ht.NewNode("Bob", args)
-	ht.RestartNodeWithExtraArgs(bob, args)
 
 	// We'll start the test by sending Charlie some coins.
 	fundingAmount := btcutil.Amount(100_000)
@@ -222,12 +221,8 @@ func testAnchorReservedValue(ht *lntest.HarnessTest) {
 	// Start two nodes supporting anchor channels.
 	args := lntest.NodeArgsForCommitType(lnrpc.CommitmentType_ANCHORS)
 
-	// NOTE: we cannot reuse the standby node here as the test requires the
-	// node to start with no UTXOs.
 	alice := ht.NewNode("Alice", args)
-	bob := ht.Bob
+	bob := ht.NewNode("Bob", args)
-	ht.RestartNodeWithExtraArgs(bob, args)
-
 	ht.ConnectNodes(alice, bob)
 
 	// Send just enough coins for Alice to open a channel without a change

itest/lnd_open_channel_test.go

@@ -34,7 +34,9 @@ func testOpenChannelAfterReorg(ht *lntest.HarnessTest) {
 	tempMiner := ht.SpawnTempMiner()
 
 	miner := ht.Miner()
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Create a new channel that requires 1 confs before it's considered
 	// open, then broadcast the funding transaction
@@ -242,9 +244,10 @@ func testOpenChannelUpdateFeePolicy(ht *lntest.HarnessTest) {
 	// In this basic test, we'll need a third node, Carol, so we can forward
 	// a payment through the channel we'll open with the different fee
 	// policies.
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
 	carol := ht.NewNode("Carol", nil)
 
-	alice, bob := ht.Alice, ht.Bob
 	nodes := []*node.HarnessNode{alice, bob, carol}
 
 	runTestCase := func(ht *lntest.HarnessTest,
@@ -301,7 +304,7 @@ func testOpenChannelUpdateFeePolicy(ht *lntest.HarnessTest) {
 
 			// Send Carol enough coins to be able to open a channel
 			// to Alice.
-			ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
+			st.FundCoins(btcutil.SatoshiPerBitcoin, carol)
 
 			runTestCase(
 				st, feeScenario,
@@ -315,7 +318,9 @@ func testOpenChannelUpdateFeePolicy(ht *lntest.HarnessTest) {
 // closing, and ensures that if a node is subscribed to channel updates they
 // will be received correctly for both cooperative and force closed channels.
 func testBasicChannelCreationAndUpdates(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	runBasicChannelCreationAndUpdates(ht, alice, bob)
 }
@@ -519,8 +524,8 @@ func testUpdateOnPendingOpenChannels(ht *lntest.HarnessTest) {
 // processing the fundee's `channel_ready`, the HTLC will be cached and
 // eventually settled.
 func testUpdateOnFunderPendingOpenChannels(ht *lntest.HarnessTest) {
-	// Grab the channel participants.
+	alice := ht.NewNodeWithCoins("Alice", nil)
-	alice, bob := ht.Alice, ht.Bob
+	bob := ht.NewNode("Bob", nil)
 
 	// Restart Alice with the config so she won't process Bob's
 	// channel_ready msg immediately.
@@ -603,8 +608,8 @@ func testUpdateOnFunderPendingOpenChannels(ht *lntest.HarnessTest) {
 // processing the funder's `channel_ready`, the HTLC will be cached and
 // eventually settled.
 func testUpdateOnFundeePendingOpenChannels(ht *lntest.HarnessTest) {
-	// Grab the channel participants.
+	alice := ht.NewNodeWithCoins("Alice", nil)
-	alice, bob := ht.Alice, ht.Bob
+	bob := ht.NewNode("Bob", nil)
 
 	// Restart Bob with the config so he won't process Alice's
 	// channel_ready msg immediately.
@@ -746,7 +751,10 @@ func verifyCloseUpdate(chanUpdate *lnrpc.ChannelEventUpdate,
 // before the funding transaction is confirmed, that the FundingExpiryBlocks
 // field of a PendingChannels decreases.
 func testFundingExpiryBlocksOnPending(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	param := lntest.OpenChannelParams{Amt: 100000}
 	update := ht.OpenChannelAssertPending(alice, bob, param)
 
@@ -844,7 +852,6 @@ func testSimpleTaprootChannelActivation(ht *lntest.HarnessTest) {
 // up as locked balance in the WalletBalance response.
 func testOpenChannelLockedBalance(ht *lntest.HarnessTest) {
 	var (
-		bob = ht.Bob
 		req *lnrpc.ChannelAcceptRequest
 		err error
 	)
@@ -852,6 +859,7 @@ func testOpenChannelLockedBalance(ht *lntest.HarnessTest) {
 	// Create a new node so we can assert exactly how much fund has been
 	// locked later.
 	alice := ht.NewNode("alice", nil)
+	bob := ht.NewNode("bob", nil)
 	ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)
 
 	// Connect the nodes.

itest/lnd_payment_test.go

@@ -346,7 +346,8 @@ func runTestPaymentHTLCTimeout(ht *lntest.HarnessTest, restartAlice bool) {
 // to return floor fee rate(1 sat/vb).
 func testSendDirectPayment(ht *lntest.HarnessTest) {
 	// Grab Alice and Bob's nodes for convenience.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// Create a list of commitment types we want to test.
 	commitmentTypes := []lnrpc.CommitmentType{
@@ -466,7 +467,9 @@ func testSendDirectPayment(ht *lntest.HarnessTest) {
 }
 
 func testListPayments(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Check that there are no payments before test.
 	ht.AssertNumPayments(alice, 0)
@@ -658,7 +661,10 @@ func testPaymentFollowingChannelOpen(ht *lntest.HarnessTest) {
 	channelCapacity := paymentAmt * 1000
 
 	// We first establish a channel between Alice and Bob.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	p := lntest.OpenChannelParams{
 		Amt: channelCapacity,
 	}
@@ -934,7 +940,9 @@ func testBidirectionalAsyncPayments(ht *lntest.HarnessTest) {
 func testInvoiceSubscriptions(ht *lntest.HarnessTest) {
 	const chanAmt = btcutil.Amount(500000)
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Create a new invoice subscription client for Bob, the notification
 	// should be dispatched shortly below.

itest/lnd_psbt_test.go

@@ -146,7 +146,7 @@ func runPsbtChanFunding(ht *lntest.HarnessTest, carol, dave *node.HarnessNode,
 
 	// Before we start the test, we'll ensure both sides are connected so
 	// the funding flow can be properly executed.
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.EnsureConnected(carol, dave)
 	ht.EnsureConnected(carol, alice)
 
@@ -344,7 +344,7 @@ func runPsbtChanFundingExternal(ht *lntest.HarnessTest, carol,
 
 	// Before we start the test, we'll ensure both sides are connected so
 	// the funding flow can be properly executed.
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	ht.EnsureConnected(carol, dave)
 	ht.EnsureConnected(carol, alice)
 
@@ -517,8 +517,7 @@ func runPsbtChanFundingSingleStep(ht *lntest.HarnessTest, carol,
 
 	const chanSize = funding.MaxBtcFundingAmount
 
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
-	ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)
 
 	// Get new address for anchor reserve.
 	req := &lnrpc.NewAddressRequest{
@@ -697,7 +696,8 @@ func testSignPsbt(ht *lntest.HarnessTest) {
 	for _, tc := range psbtTestRunners {
 		succeed := ht.Run(tc.name, func(t *testing.T) {
 			st := ht.Subtest(t)
-			tc.runner(st, st.Alice)
+			alice := st.NewNodeWithCoins("Alice", nil)
+			tc.runner(st, alice)
 		})
 
 		// Abort the test if failed.
@@ -1088,7 +1088,8 @@ func runFundAndSignPsbt(ht *lntest.HarnessTest, alice *node.HarnessNode) {
 // a PSBT that already specifies an input but where the user still wants the
 // wallet to perform coin selection.
 func testFundPsbt(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// We test a pay-join between Alice and Bob. Bob wants to send Alice
 	// 5 million Satoshis in a non-obvious way. So Bob selects a UTXO that's
@@ -1598,8 +1599,8 @@ func sendAllCoinsToAddrType(ht *lntest.HarnessTest,
 // the channel opening. The psbt funding flow is used to simulate this behavior
 // because we can easily let the remote peer run into the timeout.
 func testPsbtChanFundingFailFlow(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
-	bob := ht.Bob
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	const chanSize = funding.MaxBtcFundingAmount
 

itest/lnd_quiescence_test.go

@@ -16,7 +16,8 @@ import (
 // NOTE FOR REVIEW: this could be improved by blasting the channel with HTLC
 // traffic on both sides to increase the surface area of the change under test.
 func testQuiescence(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
 
 	chanPoint := ht.OpenChannel(bob, alice, lntest.OpenChannelParams{
 		Amt: btcutil.Amount(1000000),

itest/lnd_res_handoff_test.go

@@ -17,7 +17,8 @@ func testResHandoff(ht *lntest.HarnessTest) {
 		paymentAmt = 50000
 	)
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// First we'll create a channel between Alice and Bob.
 	ht.EnsureConnected(alice, bob)

itest/lnd_rest_api_test.go

@@ -212,13 +212,13 @@ func testRestAPI(ht *lntest.HarnessTest) {
 	// Make sure Alice allows all CORS origins. Bob will keep the default.
 	// We also make sure the ping/pong messages are sent very often, so we
 	// can test them without waiting half a minute.
-	alice, bob := ht.Alice, ht.Bob
+	bob := ht.NewNode("Bob", nil)
-	alice.Cfg.ExtraArgs = append(
+	args := []string{
-		alice.Cfg.ExtraArgs, "--restcors=\"*\"",
+		"--restcors=\"*\"",
 		fmt.Sprintf("--ws-ping-interval=%s", pingInterval),
 		fmt.Sprintf("--ws-pong-wait=%s", pongWait),
-	)
+	}
-	ht.RestartNode(alice)
+	alice := ht.NewNodeWithCoins("Alice", args)
 
 	for _, tc := range testCases {
 		tc := tc
@@ -237,7 +237,7 @@ func testRestAPI(ht *lntest.HarnessTest) {
 }
 
 func wsTestCaseSubscription(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	// Find out the current best block so we can subscribe to the next one.
 	hash, height := ht.GetBestBlock()
@@ -328,7 +328,7 @@ func wsTestCaseSubscriptionMacaroon(ht *lntest.HarnessTest) {
 	// This time we send the macaroon in the special header
 	// Sec-Websocket-Protocol which is the only header field available to
 	// browsers when opening a WebSocket.
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 	mac, err := alice.ReadMacaroon(
 		alice.Cfg.AdminMacPath, defaultTimeout,
 	)
@@ -413,7 +413,7 @@ func wsTestCaseBiDirectionalSubscription(ht *lntest.HarnessTest) {
 	// This time we send the macaroon in the special header
 	// Sec-Websocket-Protocol which is the only header field available to
 	// browsers when opening a WebSocket.
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 	mac, err := alice.ReadMacaroon(
 		alice.Cfg.AdminMacPath, defaultTimeout,
 	)
@@ -522,7 +522,7 @@ func wsTestCaseBiDirectionalSubscription(ht *lntest.HarnessTest) {
 
 	// Before we start opening channels, make sure the two nodes are
 	// connected.
-	bob := ht.Bob
+	bob := ht.NewNodeWithCoins("Bob", nil)
 	ht.EnsureConnected(alice, bob)
 
 	// Open 3 channels to make sure multiple requests and responses can be
@@ -554,7 +554,7 @@ func wsTestPingPongTimeout(ht *lntest.HarnessTest) {
 	// This time we send the macaroon in the special header
 	// Sec-Websocket-Protocol which is the only header field available to
 	// browsers when opening a WebSocket.
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 	mac, err := alice.ReadMacaroon(
 		alice.Cfg.AdminMacPath, defaultTimeout,
 	)

itest/lnd_route_blinding_test.go

@@ -26,11 +26,9 @@ import (
 // expected. It also includes the edge case of a single-hop blinded route,
 // which indicates that the introduction node is the recipient.
 func testQueryBlindedRoutes(ht *lntest.HarnessTest) {
-	var (
+	alice := ht.NewNodeWithCoins("Alice", nil)
-		// Convenience aliases.
+	bob := ht.NewNodeWithCoins("Bob", nil)
-		alice = ht.Alice
+	ht.EnsureConnected(alice, bob)
-		bob   = ht.Bob
-	)
 
 	// Setup a two hop channel network: Alice -- Bob -- Carol.
 	// We set our proportional fee for these channels to zero, so that
@@ -318,6 +316,8 @@ func testQueryBlindedRoutes(ht *lntest.HarnessTest) {
 
 type blindedForwardTest struct {
 	ht       *lntest.HarnessTest
+	alice    *node.HarnessNode
+	bob      *node.HarnessNode
 	carol    *node.HarnessNode
 	dave     *node.HarnessNode
 	channels []*lnrpc.ChannelPoint
@@ -349,11 +349,24 @@ func newBlindedForwardTest(ht *lntest.HarnessTest) (context.Context,
 func (b *blindedForwardTest) setupNetwork(ctx context.Context,
 	withInterceptor bool) {
 
+	const chanAmt = btcutil.Amount(100_000)
+
 	carolArgs := []string{"--bitcoin.timelockdelta=18"}
 	if withInterceptor {
 		carolArgs = append(carolArgs, "--requireinterceptor")
 	}
-	b.carol = b.ht.NewNode("Carol", carolArgs)
+
+	daveArgs := []string{"--bitcoin.timelockdelta=18"}
+	cfgs := [][]string{nil, nil, carolArgs, daveArgs}
+	param := lntest.OpenChannelParams{
+		Amt: chanAmt,
+	}
+
+	// Creates a network with the following topology and liquidity:
+	// Alice (100k)----- Bob (100k) ----- Carol (100k) ----- Dave
+	chanPoints, nodes := b.ht.CreateSimpleNetwork(cfgs, param)
+	b.channels = chanPoints
+	b.alice, b.bob, b.carol, b.dave = nodes[0], nodes[1], nodes[2], nodes[3]
 
 	if withInterceptor {
 		var err error
@@ -362,10 +375,6 @@ func (b *blindedForwardTest) setupNetwork(ctx context.Context,
 		)
 		require.NoError(b.ht, err, "interceptor")
 	}
-
-	b.dave = b.ht.NewNode("Dave", []string{"--bitcoin.timelockdelta=18"})
-
-	b.channels = setupFourHopNetwork(b.ht, b.carol, b.dave)
 }
 
 // buildBlindedPath returns a blinded route from Bob -> Carol -> Dave, with Bob
@@ -395,7 +404,7 @@ func (b *blindedForwardTest) buildBlindedPath() *lnrpc.BlindedPaymentPath {
 	require.Len(b.ht, payReq.BlindedPaths, 1)
 	path := payReq.BlindedPaths[0].BlindedPath
 	require.Len(b.ht, path.BlindedHops, 3)
-	require.EqualValues(b.ht, path.IntroductionNode, b.ht.Bob.PubKey[:])
+	require.EqualValues(b.ht, path.IntroductionNode, b.bob.PubKey[:])
 
 	return payReq.BlindedPaths[0]
 }
@@ -403,8 +412,8 @@ func (b *blindedForwardTest) buildBlindedPath() *lnrpc.BlindedPaymentPath {
 // cleanup tears down all channels created by the test and cancels the top
 // level context used in the test.
 func (b *blindedForwardTest) cleanup() {
-	b.ht.CloseChannel(b.ht.Alice, b.channels[0])
+	b.ht.CloseChannel(b.alice, b.channels[0])
-	b.ht.CloseChannel(b.ht.Bob, b.channels[1])
+	b.ht.CloseChannel(b.bob, b.channels[1])
 	b.ht.CloseChannel(b.carol, b.channels[2])
 
 	b.cancel()
@@ -431,7 +440,7 @@ func (b *blindedForwardTest) createRouteToBlinded(paymentAmt int64,
 		},
 	}
 
-	resp := b.ht.Alice.RPC.QueryRoutes(req)
+	resp := b.alice.RPC.QueryRoutes(req)
 	require.Greater(b.ht, len(resp.Routes), 0, "no routes")
 	require.Len(b.ht, resp.Routes[0].Hops, 3, "unexpected route length")
 
@@ -452,7 +461,7 @@ func (b *blindedForwardTest) sendBlindedPayment(ctx context.Context,
 
 	ctx, cancel := context.WithTimeout(ctx, time.Hour)
 	go func() {
-		_, err := b.ht.Alice.RPC.Router.SendToRouteV2(ctx, sendReq)
+		_, err := b.alice.RPC.Router.SendToRouteV2(ctx, sendReq)
 
 		// We may get a context canceled error when the test is
 		// finished.
@@ -481,7 +490,7 @@ func (b *blindedForwardTest) sendToRoute(route *lnrpc.Route,
 
 	// Let Alice send to the blinded payment path and assert that it
 	// succeeds/fails.
-	htlcAttempt := b.ht.Alice.RPC.SendToRouteV2(sendReq)
+	htlcAttempt := b.alice.RPC.SendToRouteV2(sendReq)
 	if assertSuccess {
 		require.Nil(b.ht, htlcAttempt.Failure)
 		require.Equal(b.ht, htlcAttempt.Status,
@@ -498,7 +507,7 @@ func (b *blindedForwardTest) sendToRoute(route *lnrpc.Route,
 	require.NoError(b.ht, err)
 
 	pmt := b.ht.AssertPaymentStatus(
-		b.ht.Alice, preimage, lnrpc.Payment_FAILED,
+		b.alice, preimage, lnrpc.Payment_FAILED,
 	)
 	require.Len(b.ht, pmt.Htlcs, 1)
 
@@ -520,7 +529,7 @@ func (b *blindedForwardTest) drainCarolLiquidity(incoming bool) {
 	receivingNode := b.dave
 
 	if incoming {
-		sendingNode = b.ht.Bob
+		sendingNode = b.bob
 		receivingNode = b.carol
 	}
 
@@ -556,7 +565,8 @@ func (b *blindedForwardTest) drainCarolLiquidity(incoming bool) {
 func setupFourHopNetwork(ht *lntest.HarnessTest,
 	carol, dave *node.HarnessNode) []*lnrpc.ChannelPoint {
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	const chanAmt = btcutil.Amount(100000)
 	var networkChans []*lnrpc.ChannelPoint
@@ -611,8 +621,6 @@ func setupFourHopNetwork(ht *lntest.HarnessTest,
 // path and forward payments in a blinded route and finally, receiving the
 // payment.
 func testBlindedRouteInvoices(ht *lntest.HarnessTest) {
-	alice := ht.Alice
-
 	ctx, testCase := newBlindedForwardTest(ht)
 	defer testCase.cleanup()
 
@@ -620,6 +628,8 @@ func testBlindedRouteInvoices(ht *lntest.HarnessTest) {
 	// blinded path that uses Bob as an introduction node.
 	testCase.setupNetwork(ctx, false)
 
+	alice := testCase.alice
+
 	// Let Dave add a blinded invoice.
 	// Add restrictions so that he only ever creates a single blinded path
 	// from Bob to himself.
@@ -737,14 +747,14 @@ func testRelayingBlindedError(ht *lntest.HarnessTest) {
 // over Alice -- Bob -- Carol -- Dave, where Bob is the introduction node and
 // has insufficient outgoing liquidity to forward on to carol.
 func testIntroductionNodeError(ht *lntest.HarnessTest) {
-	bob := ht.Bob
-
 	ctx, testCase := newBlindedForwardTest(ht)
 	defer testCase.cleanup()
 	testCase.setupNetwork(ctx, false)
 	blindedPaymentPath := testCase.buildBlindedPath()
 	route := testCase.createRouteToBlinded(10_000_000, blindedPaymentPath)
 
+	bob := testCase.bob
+
 	// Before we send our payment, drain all of Carol's incoming liquidity
 	// so that she can't receive the forward from Bob, causing a failure
 	// at the introduction node.
@@ -770,8 +780,6 @@ func testIntroductionNodeError(ht *lntest.HarnessTest) {
 // testDisableIntroductionNode tests disabling of blinded forwards for the
 // introduction node.
 func testDisableIntroductionNode(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
-
 	// First construct a blinded route while Bob is still advertising the
 	// route blinding feature bit to ensure that Bob is included in the
 	// blinded path that Dave selects.
@@ -781,6 +789,8 @@ func testDisableIntroductionNode(ht *lntest.HarnessTest) {
 	blindedPaymentPath := testCase.buildBlindedPath()
 	route := testCase.createRouteToBlinded(10_000_000, blindedPaymentPath)
 
+	alice, bob := testCase.alice, testCase.bob
+
 	// Now, disable route blinding for Bob, then re-connect to Alice.
 	ht.RestartNodeWithExtraArgs(bob, []string{
 		"--protocol.no-route-blinding",
@@ -796,8 +806,6 @@ func testDisableIntroductionNode(ht *lntest.HarnessTest) {
 // to resolve blinded HTLCs on chain between restarts, as we've got all the
 // infrastructure in place already for error testing.
 func testErrorHandlingOnChainFailure(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
-
 	// Setup a test case, note that we don't use its built in clean up
 	// because we're going to close a channel, so we'll close out the
 	// rest manually.
@@ -811,6 +819,8 @@ func testErrorHandlingOnChainFailure(ht *lntest.HarnessTest) {
 		50_000_000, blindedPaymentPath,
 	)
 
+	alice, bob := testCase.alice, testCase.bob
+
 	// Once our interceptor is set up, we can send the blinded payment.
 	cancelPmt := testCase.sendBlindedPayment(ctx, blindedRoute)
 	defer cancelPmt()
@@ -917,8 +927,8 @@ func testErrorHandlingOnChainFailure(ht *lntest.HarnessTest) {
 func testMPPToSingleBlindedPath(ht *lntest.HarnessTest) {
 	// Create a five-node context consisting of Alice, Bob and three new
 	// nodes.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNode("Alice", nil)
-
+	bob := ht.NewNode("Bob", nil)
 	dave := ht.NewNode("dave", nil)
 	carol := ht.NewNode("carol", nil)
 	eve := ht.NewNode("eve", nil)
@@ -932,10 +942,12 @@ func testMPPToSingleBlindedPath(ht *lntest.HarnessTest) {
 
 	// Send coins to the nodes and mine 1 blocks to confirm them.
 	for i := 0; i < 2; i++ {
+		ht.FundCoinsUnconfirmed(btcutil.SatoshiPerBitcoin, alice)
+		ht.FundCoinsUnconfirmed(btcutil.SatoshiPerBitcoin, bob)
 		ht.FundCoinsUnconfirmed(btcutil.SatoshiPerBitcoin, carol)
 		ht.FundCoinsUnconfirmed(btcutil.SatoshiPerBitcoin, dave)
 		ht.FundCoinsUnconfirmed(btcutil.SatoshiPerBitcoin, eve)
-		ht.MineBlocksAndAssertNumTxes(1, 3)
+		ht.MineBlocksAndAssertNumTxes(1, 5)
 	}
 
 	const paymentAmt = btcutil.Amount(300000)
@@ -1107,11 +1119,11 @@ func testMPPToSingleBlindedPath(ht *lntest.HarnessTest) {
 // between him and the introduction node. So we expect that Carol is chosen as
 // the intro node and that one dummy hops is appended.
 func testBlindedRouteDummyHops(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
 
 	// Disable route blinding for Bob so that he is never chosen as the
 	// introduction node.
-	ht.RestartNodeWithExtraArgs(bob, []string{
+	bob := ht.NewNodeWithCoins("Bob", []string{
 		"--protocol.no-route-blinding",
 	})
 
@@ -1278,7 +1290,8 @@ func testBlindedRouteDummyHops(ht *lntest.HarnessTest) {
 //		  \	       /
 //		   --- Carol ---
 func testMPPToMultipleBlindedPaths(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// Create a four-node context consisting of Alice, Bob and three new
 	// nodes.
@@ -1440,8 +1453,6 @@ func testMPPToMultipleBlindedPaths(ht *lntest.HarnessTest) {
 // UpdateAddHTLC which we need to ensure gets included in the message on
 // restart.
 func testBlindedPaymentHTLCReForward(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
-
 	// Setup a test case.
 	ctx, testCase := newBlindedForwardTest(ht)
 	defer testCase.cleanup()
@@ -1449,6 +1460,8 @@ func testBlindedPaymentHTLCReForward(ht *lntest.HarnessTest) {
 	// Set up network with carol interceptor.
 	testCase.setupNetwork(ctx, true)
 
+	alice, bob := testCase.alice, testCase.bob
+
 	// Let dave create invoice.
 	blindedPaymentPath := testCase.buildBlindedPath()
 	route := testCase.createRouteToBlinded(10_000_000, blindedPaymentPath)
@@ -1465,7 +1478,7 @@ func testBlindedPaymentHTLCReForward(ht *lntest.HarnessTest) {
 	go func() {
 		defer close(done)
 
-		htlcAttempt, err := testCase.ht.Alice.RPC.Router.SendToRouteV2(
+		htlcAttempt, err := testCase.alice.RPC.Router.SendToRouteV2(
 			ctx, sendReq,
 		)
 		require.NoError(testCase.ht, err)

itest/lnd_routing_test.go

@@ -317,9 +317,8 @@ func runMultiHopSendToRoute(ht *lntest.HarnessTest, useGraphCache bool) {
 		opts = append(opts, "--db.no-graph-cache")
 	}
 
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", opts)
-	ht.RestartNodeWithExtraArgs(alice, opts)
+	bob := ht.NewNodeWithCoins("Bob", opts)
-
 	ht.EnsureConnected(alice, bob)
 
 	const chanAmt = btcutil.Amount(100000)
@@ -417,7 +416,10 @@ func testSendToRouteErrorPropagation(ht *lntest.HarnessTest) {
 
 	// Open a channel with 100k satoshis between Alice and Bob with Alice
 	// being the sole funder of the channel.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	chanPointAlice := ht.OpenChannel(
 		alice, bob, lntest.OpenChannelParams{Amt: chanAmt},
 	)
@@ -496,7 +498,10 @@ func testPrivateChannels(ht *lntest.HarnessTest) {
 	// where the 100k channel between Carol and Alice is private.
 
 	// Open a channel with 200k satoshis between Alice and Bob.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNode("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	chanPointAlice := ht.OpenChannel(
 		alice, bob, lntest.OpenChannelParams{Amt: chanAmt * 2},
 	)
@@ -618,7 +623,10 @@ func testInvoiceRoutingHints(ht *lntest.HarnessTest) {
 	// throughout this test. We'll include a push amount since we currently
 	// require channels to have enough remote balance to cover the
 	// invoice's payment.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	chanPointBob := ht.OpenChannel(
 		alice, bob, lntest.OpenChannelParams{
 			Amt:     chanAmt,
@@ -750,7 +758,7 @@ func testInvoiceRoutingHints(ht *lntest.HarnessTest) {
 // testScidAliasRoutingHints tests that dynamically created aliases via the RPC
 // are properly used when routing.
 func testScidAliasRoutingHints(ht *lntest.HarnessTest) {
-	bob := ht.Bob
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	const chanAmt = btcutil.Amount(800000)
 
@@ -948,7 +956,10 @@ func testMultiHopOverPrivateChannels(ht *lntest.HarnessTest) {
 
 	// First, we'll open a private channel between Alice and Bob with Alice
 	// being the funder.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	chanPointAlice := ht.OpenChannel(
 		alice, bob, lntest.OpenChannelParams{
 			Amt:     chanAmt,
@@ -958,7 +969,7 @@ func testMultiHopOverPrivateChannels(ht *lntest.HarnessTest) {
 
 	// Next, we'll create Carol's node and open a public channel between
 	// her and Bob with Bob being the funder.
-	carol := ht.NewNode("Carol", nil)
+	carol := ht.NewNodeWithCoins("Carol", nil)
 	ht.ConnectNodes(bob, carol)
 	chanPointBob := ht.OpenChannel(
 		bob, carol, lntest.OpenChannelParams{
@@ -973,7 +984,6 @@ func testMultiHopOverPrivateChannels(ht *lntest.HarnessTest) {
 	// him and Carol with Carol being the funder.
 	dave := ht.NewNode("Dave", nil)
 	ht.ConnectNodes(carol, dave)
-	ht.FundCoins(btcutil.SatoshiPerBitcoin, carol)
 
 	chanPointCarol := ht.OpenChannel(
 		carol, dave, lntest.OpenChannelParams{
@@ -1050,7 +1060,9 @@ func testQueryRoutes(ht *lntest.HarnessTest) {
 	const chanAmt = btcutil.Amount(100000)
 
 	// Grab Alice and Bob from the standby nodes.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
 
 	// Create Carol and connect her to Bob. We also send her some coins for
 	// channel opening.
@@ -1353,7 +1365,10 @@ func testRouteFeeCutoff(ht *lntest.HarnessTest) {
 	const chanAmt = btcutil.Amount(100000)
 
 	// Open a channel between Alice and Bob.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", nil)
+	ht.EnsureConnected(alice, bob)
+
 	chanPointAliceBob := ht.OpenChannel(
 		alice, bob, lntest.OpenChannelParams{Amt: chanAmt},
 	)

itest/lnd_signer_test.go

@@ -25,7 +25,7 @@ import (
 // the node's pubkey and a customized public key to check the validity of the
 // result.
 func testDeriveSharedKey(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	runDeriveSharedKey(ht, alice)
 }
@@ -199,7 +199,7 @@ func runDeriveSharedKey(ht *lntest.HarnessTest, alice *node.HarnessNode) {
 // testSignOutputRaw makes sure that the SignOutputRaw RPC can be used with all
 // custom ways of specifying the signing key in the key descriptor/locator.
 func testSignOutputRaw(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 
 	runSignOutputRaw(ht, alice)
 }
@@ -381,7 +381,7 @@ func assertSignOutputRaw(ht *lntest.HarnessTest,
 // all custom flags by verifying with VerifyMessage. Tests both ECDSA and
 // Schnorr signatures.
 func testSignVerifyMessage(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	runSignVerifyMessage(ht, alice)
 }

itest/lnd_single_hop_invoice_test.go

@@ -18,10 +18,11 @@ func testSingleHopInvoice(ht *lntest.HarnessTest) {
 	// Open a channel with 100k satoshis between Alice and Bob with Alice
 	// being the sole funder of the channel.
 	chanAmt := btcutil.Amount(100000)
-	alice, bob := ht.Alice, ht.Bob
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	cp := ht.OpenChannel(
+		[][]string{nil, nil}, lntest.OpenChannelParams{Amt: chanAmt},
-		alice, bob, lntest.OpenChannelParams{Amt: chanAmt},
 	)
+	cp := chanPoints[0]
+	alice, bob := nodes[0], nodes[1]
 
 	// assertAmountPaid is a helper closure that asserts the amount paid by
 	// Alice and received by Bob are expected.

itest/lnd_sweep_test.go

@@ -1558,7 +1558,7 @@ func testSweepCommitOutputAndAnchor(ht *lntest.HarnessTest) {
 // CPFP, then RBF. Along the way, we check the `BumpFee` can properly update
 // the fee function used by supplying new params.
 func testBumpFee(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 
 	runBumpFee(ht, alice)
 }

itest/lnd_switch_test.go

@@ -383,7 +383,9 @@ func setupScenarioFourNodes(ht *lntest.HarnessTest) *scenarioFourNodes {
 	}
 
 	// Grab the standby nodes.
-	alice, bob := ht.Alice, ht.Bob
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("bob", nil)
+	ht.ConnectNodes(alice, bob)
 
 	// As preliminary setup, we'll create two new nodes: Carol and Dave,
 	// such that we now have a 4 node, 3 channel topology. Dave will make

itest/lnd_taproot_test.go

@@ -49,7 +49,7 @@ var (
 // testTaproot ensures that the daemon can send to and spend from taproot (p2tr)
 // outputs.
 func testTaproot(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	testTaprootSendCoinsKeySpendBip86(ht, alice)
 	testTaprootComputeInputScriptKeySpendBip86(ht, alice)

itest/lnd_trackpayments_test.go

@@ -14,21 +14,19 @@ import (
 // testTrackPayments tests whether a client that calls the TrackPayments api
 // receives payment updates.
 func testTrackPayments(ht *lntest.HarnessTest) {
-	alice, bob := ht.Alice, ht.Bob
+	// Create Alice with the new flag so she understands the new payment
-
-	// Restart Alice with the new flag so she understands the new payment
 	// status.
-	ht.RestartNodeWithExtraArgs(alice, []string{
+	cfgAlice := []string{"--routerrpc.usestatusinitiated"}
-		"--routerrpc.usestatusinitiated",
+	cfgs := [][]string{cfgAlice, nil}
-	})
 
-	// Open a channel between alice and bob.
+	// Create a channel Alice->Bob.
-	ht.EnsureConnected(alice, bob)
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	channel := ht.OpenChannel(
+		cfgs, lntest.OpenChannelParams{
-		alice, bob, lntest.OpenChannelParams{
 			Amt: btcutil.Amount(300000),
 		},
 	)
+	channel := chanPoints[0]
+	alice, bob := nodes[0], nodes[1]
 
 	// Call the TrackPayments api to listen for payment updates.
 	req := &routerrpc.TrackPaymentsRequest{
@@ -104,12 +102,13 @@ func testTrackPayments(ht *lntest.HarnessTest) {
 // is not set, the new Payment_INITIATED is replaced with Payment_IN_FLIGHT.
 func testTrackPaymentsCompatible(ht *lntest.HarnessTest) {
 	// Open a channel between alice and bob.
-	alice, bob := ht.Alice, ht.Bob
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	channel := ht.OpenChannel(
+		[][]string{nil, nil}, lntest.OpenChannelParams{
-		alice, bob, lntest.OpenChannelParams{
 			Amt: btcutil.Amount(300000),
 		},
 	)
+	channel := chanPoints[0]
+	alice, bob := nodes[0], nodes[1]
 
 	// Call the TrackPayments api to listen for payment updates.
 	req := &routerrpc.TrackPaymentsRequest{

itest/lnd_wallet_import_test.go

@@ -582,7 +582,7 @@ func runWalletImportAccountScenario(ht *lntest.HarnessTest,
 
 	// Send coins to Carol's address and confirm them, making sure the
 	// balance updates accordingly.
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 	req := &lnrpc.SendCoinsRequest{
 		Addr:       externalAddr,
 		Amount:     utxoAmt,
@@ -694,7 +694,7 @@ func testWalletImportPubKeyScenario(ht *lntest.HarnessTest,
 	addrType walletrpc.AddressType) {
 
 	const utxoAmt int64 = btcutil.SatoshiPerBitcoin
-	alice := ht.Alice
+	alice := ht.NewNodeWithCoins("Alice", nil)
 
 	// We'll start our test by having two nodes, Carol and Dave.
 	//

itest/lnd_watchtower_test.go

@@ -39,7 +39,7 @@ var watchtowerTestCases = []*lntest.TestCase{
 // testTowerClientTowerAndSessionManagement tests the various control commands
 // that a user has over the client's set of active towers and sessions.
 func testTowerClientTowerAndSessionManagement(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	const (
 		chanAmt           = funding.MaxBtcFundingAmount
@@ -240,7 +240,7 @@ func testTowerClientTowerAndSessionManagement(ht *lntest.HarnessTest) {
 // testTowerClientSessionDeletion tests that sessions are correctly deleted
 // when they are deemed closable.
 func testTowerClientSessionDeletion(ht *lntest.HarnessTest) {
-	alice := ht.Alice
+	alice := ht.NewNode("Alice", nil)
 
 	const (
 		chanAmt           = funding.MaxBtcFundingAmount
@@ -395,7 +395,7 @@ func testRevokedCloseRetributionAltruistWatchtowerCase(ht *lntest.HarnessTest,
 	// protection logic automatically.
 	daveArgs := lntest.NodeArgsForCommitType(commitType)
 	daveArgs = append(daveArgs, "--nolisten", "--wtclient.active")
-	dave := ht.NewNode("Dave", daveArgs)
+	dave := ht.NewNodeWithCoins("Dave", daveArgs)
 
 	addTowerReq := &wtclientrpc.AddTowerRequest{
 		Pubkey:  willyInfoPk,
@@ -407,10 +407,6 @@ func testRevokedCloseRetributionAltruistWatchtowerCase(ht *lntest.HarnessTest,
 	// announcement, so we open a channel with Carol,
 	ht.ConnectNodes(dave, carol)
 
-	// Before we make a channel, we'll load up Dave with some coins sent
-	// directly from the miner.
-	ht.FundCoins(btcutil.SatoshiPerBitcoin, dave)
-
 	// Send one more UTXOs if this is a neutrino backend.
 	if ht.IsNeutrinoBackend() {
 		ht.FundCoins(btcutil.SatoshiPerBitcoin, dave)

itest/lnd_wipe_fwdpkgs_test.go

@@ -27,25 +27,12 @@ func testWipeForwardingPackages(ht *lntest.HarnessTest) {
 		numInvoices    = 3
 	)
 
-	// Grab Alice and Bob from HarnessTest.
+	chanPoints, nodes := ht.CreateSimpleNetwork(
-	alice, bob := ht.Alice, ht.Bob
+		[][]string{nil, nil, nil},
-
+		lntest.OpenChannelParams{Amt: chanAmt},
-	// Create a new node Carol, which will create invoices that require
-	// Alice to pay.
-	carol := ht.NewNode("Carol", nil)
-
-	// Connect Bob to Carol.
-	ht.ConnectNodes(bob, carol)
-
-	// Open a channel between Alice and Bob.
-	chanPointAB := ht.OpenChannel(
-		alice, bob, lntest.OpenChannelParams{Amt: chanAmt},
-	)
-
-	// Open a channel between Bob and Carol.
-	chanPointBC := ht.OpenChannel(
-		bob, carol, lntest.OpenChannelParams{Amt: chanAmt},
 	)
+	chanPointAB, chanPointBC := chanPoints[0], chanPoints[1]
+	alice, bob, carol := nodes[0], nodes[1], nodes[2]
 
 	// Before we continue, make sure Alice has seen the channel between Bob
 	// and Carol.

itest/lnd_zero_conf_test.go

@@ -753,7 +753,7 @@ func testPrivateUpdateAlias(ht *lntest.HarnessTest,
 // testOptionScidUpgrade tests that toggling the option-scid-alias feature bit
 // correctly upgrades existing channels.
 func testOptionScidUpgrade(ht *lntest.HarnessTest) {
-	bob := ht.Bob
+	bob := ht.NewNodeWithCoins("Bob", nil)
 
 	// Start carol with anchors only.
 	carolArgs := []string{

lntest/harness.go

@@ -603,6 +603,42 @@ func (h *HarnessTest) NewNode(name string,
 	return node
 }
 
+// NewNodeWithCoins creates a new node and asserts its creation. The node is
+// guaranteed to have finished its initialization and all its subservers are
+// started. In addition, 5 UTXO of 1 BTC each are sent to the node.
+func (h *HarnessTest) NewNodeWithCoins(name string,
+	extraArgs []string) *node.HarnessNode {
+
+	node, err := h.manager.newNode(h.T, name, extraArgs, nil, false)
+	require.NoErrorf(h, err, "unable to create new node for %s", name)
+
+	// Start the node.
+	err = node.Start(h.runCtx)
+	require.NoError(h, err, "failed to start node %s", node.Name())
+
+	// Load up the wallets of the node with 5 outputs of 1 BTC each.
+	const (
+		numOutputs  = 5
+		fundAmount  = 1 * btcutil.SatoshiPerBitcoin
+		totalAmount = fundAmount * numOutputs
+	)
+
+	for i := 0; i < numOutputs; i++ {
+		h.createAndSendOutput(
+			node, fundAmount,
+			lnrpc.AddressType_WITNESS_PUBKEY_HASH,
+		)
+	}
+
+	// Mine a block to confirm the transactions.
+	h.MineBlocksAndAssertNumTxes(1, numOutputs)
+
+	// Now block until the wallet have fully synced up.
+	h.WaitForBalanceConfirmed(node, totalAmount)
+
+	return node
+}
+
 // Shutdown shuts down the given node and asserts that no errors occur.
 func (h *HarnessTest) Shutdown(node *node.HarnessNode) {
 	// The process may not be in a state to always shutdown immediately, so