itest+lntest: add tests for sat/kw option

Add new itests for openchannel, sendcoins and  sendmany.

Fix the test "rbf coop close" that was broken by
a safety check added to prevent very high fees.

Change the test "runWalletImportAccountScenario" to
start using SatPerVbyte field instead of the deprecated
fiels SatPerByte.

Author: MPins

itest/list_on_test.go

@@ -615,6 +615,18 @@ var allTestCases = []*lntest.TestCase{
 		Name:     "route blinding dummy hops",
 		TestFunc: testBlindedRouteDummyHops,
 	},
+	{
+		Name:     "openchannel feerate",
+		TestFunc: testOpenChannelFeerate,
+	},
+	{
+		Name:     "sendcoins feerate",
+		TestFunc: testSendCoinsFeerate,
+	},
+	{
+		Name:     "sendmany feerate",
+		TestFunc: testSendManyFeerate,
+	},
 	{
 		Name:     "removetx",
 		TestFunc: testRemoveTx,

itest/lnd_coop_close_rbf_test.go

@@ -19,8 +19,8 @@ func testCoopCloseRbf(ht *lntest.HarnessTest) {
 	// enough coins to make a 50/50 channel.
 	cfgs := [][]string{rbfCoopFlags, rbfCoopFlags}
 	params := lntest.OpenChannelParams{
-		Amt:     btcutil.Amount(1000000),
-		PushAmt: btcutil.Amount(1000000 / 2),
+		Amt:     btcutil.Amount(100000),
+		PushAmt: btcutil.Amount(100000 / 2),
 	}
 	chanPoints, nodes := ht.CreateSimpleNetwork(cfgs, params)
 	alice, bob := nodes[0], nodes[1]
@@ -92,8 +92,9 @@ func testCoopCloseRbf(ht *lntest.HarnessTest) {
 	_, err = ht.ReceiveCloseChannelUpdate(bobCloseStream)
 	require.NoError(ht, err)
 
-	// We'll now attempt a fee update that we can't actually pay for. This
-	// will actually show up as an error to the remote party.
+	// We'll now attempt a fee update greater than DefaultMaxFeeRate. It
+	// will be capped at DefaultMaxFeeRate, but we still can't afford it.
+	// This will result in an error shown to the remote party.
 	aliceRejectedFeeRate = 100_000
 	_, _ = ht.CloseChannelAssertPending(
 		alice, chanPoint, false,

itest/lnd_onchain_test.go

@@ -153,7 +153,7 @@ func testChainKitSendOutputsAnchorReserve(ht *lntest.HarnessTest) {
 	// Charlie opens an anchor channel and keeps twice the amount of the
 	// anchor reserve in her wallet.
 	chanAmt := fundingAmount - 2*btcutil.Amount(reserve.RequiredReserve)
-	ht.OpenChannel(charlie, bob, lntest.OpenChannelParams{
+	outpoint := ht.OpenChannel(charlie, bob, lntest.OpenChannelParams{
 		Amt:            chanAmt,
 		CommitmentType: lnrpc.CommitmentType_ANCHORS,
 		SatPerVByte:    1,
@@ -208,6 +208,9 @@ func testChainKitSendOutputsAnchorReserve(ht *lntest.HarnessTest) {
 	// This second transaction should be published correctly.
 	charlie.RPC.SendOutputs(req)
 	ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Clean up our test setup.
+	ht.CloseChannel(charlie, outpoint)
 }
 
 // testAnchorReservedValue tests that we won't allow sending transactions when
@@ -898,3 +901,134 @@ func testListSweeps(ht *lntest.HarnessTest) {
 	}
 	ht.AssertNumSweeps(alice, req4, 0)
 }
+
+// testSendCoinsFeerate tests that we can create transaction with a specified
+// feerate in either sats_per_vbyte and sats_per_kweight.
+func testSendCoinsFeerate(ht *lntest.HarnessTest) {
+	alice := ht.NewNode("Alice", nil)
+	// Send Alice enough coins to be able to call SendCoins.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)
+	minerAddr := ht.Miner().NewMinerAddress()
+
+	sweepReq := &lnrpc.SendCoinsRequest{
+		Addr:        minerAddr.String(),
+		SatPerVbyte: 2,
+		Amount:      10001,
+	}
+	_ = alice.RPC.SendCoins(sweepReq)
+
+	// We'll mine a block which should include the sweep transaction we
+	// generated above.
+	block := ht.MineBlocksAndAssertNumTxes(1, 1)[0]
+	sweepTx := block.Transactions[1].TxHash()
+
+	// Calculate the feerate of the funding transaction in sat_per_vbyte.
+	rawTx := ht.Miner().GetRawTransaction(sweepTx)
+	feerate := ht.CalculateFeeRateSatPerVByte(rawTx.MsgTx())
+
+	// Allow some deviation because weight estimates during tx generation
+	// are estimates (ECDSA signature size estimate).
+	require.InEpsilon(ht, int64(sweepReq.SatPerVbyte), feerate, 0.01)
+
+	// Send coins with a defined feerate in sat_per_kw.
+	sweepReq = &lnrpc.SendCoinsRequest{
+		Addr:     minerAddr.String(),
+		SatPerKw: 5000,
+		Amount:   10002,
+	}
+	_ = alice.RPC.SendCoins(sweepReq)
+
+	// We'll mine a block which should include the sweep transaction we
+	// generated above.
+	block = ht.MineBlocksAndAssertNumTxes(1, 1)[0]
+	sweepTx = block.Transactions[1].TxHash()
+
+	// Calculate the feerate of the funding transaction in sat_per_kw.
+	rawTx = ht.Miner().GetRawTransaction(sweepTx)
+	feerate = ht.CalculateFeeRateSatPerKWeight(rawTx.MsgTx())
+
+	// Allow some deviation because weight estimates during tx generation
+	// are estimates (ECDSA signature size estimate).
+	require.InEpsilon(ht, int64(sweepReq.SatPerKw), feerate, 0.01)
+
+	// Try sending coins with both feerate options sat_per_kw and
+	// sat_per_vbyte specified.
+	sweepReq = &lnrpc.SendCoinsRequest{
+		Addr:        minerAddr.String(),
+		SatPerKw:    500,
+		SatPerVbyte: 2,
+		SendAll:     true,
+	}
+
+	// This should fail because only one feerate option makes sense.
+	err := alice.RPC.SendCoinsAssertErr(sweepReq)
+	require.Error(ht, err, "either SatPerKW or SatPerVByte should "+
+		"be set, but not both")
+}
+
+// testSendManyFeerate tests that we can create transaction with many outputs
+// with a specified feerate in either sats_per_vbyte and sats_per_kweight.
+func testSendManyFeerate(ht *lntest.HarnessTest) {
+	alice := ht.NewNode("Alice", nil)
+	// Send Alice enough coins to be able to call SendCoins.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)
+	addr1 := ht.Miner().NewMinerAddress().String()
+	addr2 := ht.Miner().NewMinerAddress().String()
+
+	addrAmtMap := map[string]int64{
+		addr1: 50000,
+		addr2: 50000,
+	}
+
+	// We create the transaction specifying the feerate in sats_per_vbyte.
+	sendManyReq := &lnrpc.SendManyRequest{
+		AddrToAmount: addrAmtMap,
+		SatPerVbyte:  2,
+	}
+	_ = alice.RPC.SendMany(sendManyReq)
+
+	// We'll mine a block which should include the sweep transaction we
+	// generated above.
+	block := ht.MineBlocksAndAssertNumTxes(1, 1)[0]
+	sweepTx := block.Transactions[1].TxHash()
+
+	// Calculate the feerate of the funding transaction in sat_per_vbyte.
+	rawTx := ht.Miner().GetRawTransaction(sweepTx)
+	feerate := ht.CalculateFeeRateSatPerVByte(rawTx.MsgTx())
+
+	// Allow some deviation because weight estimates during tx generation
+	// are estimates (ECDSA signature size estimate).
+	require.InEpsilon(ht, int64(sendManyReq.SatPerVbyte), feerate, 0.01)
+
+	// We create the transaction specifying the feerate in
+	// sats_per_kweight.
+	sendManyReq = &lnrpc.SendManyRequest{
+		AddrToAmount: addrAmtMap,
+		SatPerKw:     2000,
+	}
+	_ = alice.RPC.SendMany(sendManyReq)
+
+	// We'll mine a block which should include the sweep transaction we
+	// generated above.
+	block = ht.MineBlocksAndAssertNumTxes(1, 1)[0]
+	sweepTx = block.Transactions[1].TxHash()
+
+	// Calculate the feerate of the funding transaction in sats_per_kweight.
+	rawTx = ht.Miner().GetRawTransaction(sweepTx)
+	feerate = ht.CalculateFeeRateSatPerKWeight(rawTx.MsgTx())
+
+	// Allow some deviation because weight estimates during tx generation
+	// are estimates (ECDSA signature size estimate).
+	require.InEpsilon(ht, int64(sendManyReq.SatPerKw), feerate, 0.01)
+
+	// Try sending coins with both feerate options sat_per_kw and
+	// sat_per_vbyte specified.
+	sendManyReq = &lnrpc.SendManyRequest{
+		AddrToAmount: addrAmtMap,
+		SatPerKw:     2000,
+		SatPerVbyte:  3,
+	}
+
+	// This should fail because only one feerate option makes sense.
+	alice.RPC.SendManyAssertErr(sendManyReq)
+}

itest/lnd_open_channel_test.go

@@ -1039,3 +1039,66 @@ func testFundingManagerFundingTimeout(ht *lntest.HarnessTest) {
 	// Cleanup the mempool by mining blocks.
 	ht.MineBlocksAndAssertNumTxes(6, 1)
 }
+
+// testOpenChannelFeerate tests that we can open a channel with a specified
+// feerate either in sat_per_vbyte or in sat_per_kweight.
+func testOpenChannelFeerate(ht *lntest.HarnessTest) {
+	alice, bob := ht.NewNode("Alice", nil), ht.NewNode("Bob", nil)
+
+	// Ensure Alice is connected to Bob.
+	ht.EnsureConnected(alice, bob)
+
+	// Send Alice enough coins to be able to call OpenChannel.
+	ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)
+
+	chanAmt := funding.MaxBtcFundingAmount / 3
+
+	// First we test opening a channel by specifying the feerate in
+	// sat_per_kweight
+	params := lntest.OpenChannelParams{
+		Amt:           chanAmt,
+		SatPerKWeight: 500,
+	}
+
+	// Create a channel Alice->Bob.
+	chanPoint := ht.OpenChannel(alice, bob, params)
+	defer ht.CloseChannel(alice, chanPoint)
+
+	// Calculate the feerate of the funding transaction.
+	fundingTxID := ht.GetChanPointFundingTxid(chanPoint)
+	rawTx := ht.Miner().GetRawTransaction(fundingTxID)
+	feerate := ht.CalculateFeeRateSatPerKWeight(rawTx.MsgTx())
+
+	// Allow some deviation because weight estimates during tx generation
+	// are estimates (ECDSA signature size estimate).
+	require.InEpsilon(ht, int64(params.SatPerKWeight), feerate, 0.01)
+
+	// Now we open another channel with the feerate sat_per_vbyte
+	params = lntest.OpenChannelParams{
+		Amt:         chanAmt,
+		SatPerVByte: 100,
+	}
+
+	// Create a channel Alice->Bob.
+	chanPoint = ht.OpenChannel(alice, bob, params)
+	defer ht.CloseChannel(alice, chanPoint)
+
+	// Calculate the feerate of the funding transaction.
+	fundingTxID = ht.GetChanPointFundingTxid(chanPoint)
+	rawTx = ht.Miner().GetRawTransaction(fundingTxID)
+	feerate = ht.CalculateFeeRateSatPerVByte(rawTx.MsgTx())
+
+	// Allow some deviation because weight estimates during tx generation
+	// are estimates (ECDSA signature size estimate).
+	require.InEpsilon(ht, int64(params.SatPerVByte), feerate, 0.01)
+
+	// Test when specififying both feerate options we should fail.
+	params = lntest.OpenChannelParams{
+		Amt:           chanAmt,
+		SatPerVByte:   2,
+		SatPerKWeight: 500,
+	}
+
+	ht.OpenChannelAssertErr(alice, bob, params, fmt.Errorf("either "+
+		"SatPerKWeight or SatPerVByte should be set, but not both"))
+}

itest/lnd_wallet_import_test.go

@@ -566,9 +566,9 @@ func runWalletImportAccountScenario(ht *lntest.HarnessTest,
 	// balance updates accordingly.
 	alice := ht.NewNodeWithCoins("Alice", nil)
 	req := &lnrpc.SendCoinsRequest{
-		Addr:       externalAddr,
-		Amount:     utxoAmt,
-		SatPerByte: 1,
+		Addr:        externalAddr,
+		Amount:      utxoAmt,
+		SatPerVbyte: 1,
 	}
 	alice.RPC.SendCoins(req)
 
@@ -599,9 +599,9 @@ func runWalletImportAccountScenario(ht *lntest.HarnessTest,
 	// Send coins to Carol's address and confirm them, making sure the
 	// balance updates accordingly.
 	req = &lnrpc.SendCoinsRequest{
-		Addr:       externalAddr,
-		Amount:     utxoAmt,
-		SatPerByte: 1,
+		Addr:        externalAddr,
+		Amount:      utxoAmt,
+		SatPerVbyte: 1,
 	}
 	alice.RPC.SendCoins(req)
 
@@ -739,9 +739,9 @@ func testWalletImportPubKeyScenario(ht *lntest.HarnessTest,
 		// Send coins to Carol's address and confirm them, making sure
 		// the balance updates accordingly.
 		req := &lnrpc.SendCoinsRequest{
-			Addr:       carolAddrResp.Address,
-			Amount:     utxoAmt,
-			SatPerByte: 1,
+			Addr:        carolAddrResp.Address,
+			Amount:      utxoAmt,
+			SatPerVbyte: 1,
 		}
 		alice.RPC.SendCoins(req)