itest: add fee estimation + input types itest

In this commit, we add a new itest that exercises the minter and
freighter when using multiple input types like P2WKH and various fee
rates.

Author: jharveyb

itest/assertions.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
+	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/rpcclient"
 	"github.com/btcsuite/btcd/wire"
@@ -24,6 +25,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/universe"
 	"github.com/lightningnetwork/lnd/lnrpc/chainrpc"
 	"github.com/lightningnetwork/lnd/lntest/wait"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/maps"
 )
@@ -219,6 +221,75 @@ func AssertTxInBlock(t *testing.T, block *wire.MsgBlock,
 	return nil
 }
 
+// AssertTransferFeeRate checks that fee paid for the TX anchoring an asset
+// transfer is close to the expected fee for that TX, at a given fee rate.
+func AssertTransferFeeRate(t *testing.T, minerClient *rpcclient.Client,
+	transferResp *taprpc.SendAssetResponse, inputAmt int64,
+	feeRate chainfee.SatPerKWeight, roundFee bool) {
+
+	txid, err := chainhash.NewHash(transferResp.Transfer.AnchorTxHash)
+	require.NoError(t, err)
+
+	AssertFeeRate(t, minerClient, inputAmt, txid, feeRate, roundFee)
+}
+
+// AssertFeeRate checks that the fee paid for a given TX is close to the
+// expected fee for the same TX, at a given fee rate.
+func AssertFeeRate(t *testing.T, minerClient *rpcclient.Client, inputAmt int64,
+	txid *chainhash.Hash, feeRate chainfee.SatPerKWeight, roundFee bool) {
+
+	var (
+		outputValue                 float64
+		expectedFee, maxOverpayment btcutil.Amount
+		maxVsizeDifference          = int64(2)
+	)
+
+	verboseTx, err := minerClient.GetRawTransactionVerbose(txid)
+	require.NoError(t, err)
+
+	vsize := verboseTx.Vsize
+	for _, vout := range verboseTx.Vout {
+		outputValue += vout.Value
+	}
+
+	t.Logf("TX vsize of %d bytes", vsize)
+
+	btcOutputValue, err := btcutil.NewAmount(outputValue)
+	require.NoError(t, err)
+
+	actualFee := inputAmt - int64(btcOutputValue)
+
+	switch {
+	case roundFee:
+		// Replicate the rounding performed when calling `FundPsbt`.
+		feeSatPerVbyte := uint64(feeRate.FeePerKVByte()) / 1000
+		roundedFeeRate := chainfee.SatPerKVByte(
+			feeSatPerVbyte * 1000,
+		).FeePerKWeight()
+
+		expectedFee = roundedFeeRate.FeePerKVByte().
+			FeeForVSize(int64(vsize))
+		maxOverpayment = roundedFeeRate.FeePerKVByte().
+			FeeForVSize(maxVsizeDifference)
+
+	default:
+		expectedFee = feeRate.FeePerKVByte().
+			FeeForVSize(int64(vsize))
+		maxOverpayment = feeRate.FeePerKVByte().
+			FeeForVSize(maxVsizeDifference)
+	}
+
+	// The actual fee may be higher than the expected fee after
+	// confirmation, as the freighter makes a worst-case estimate of the TX
+	// vsize. The gap between these two fees should still be small.
+	require.GreaterOrEqual(t, actualFee, int64(expectedFee))
+
+	overpaidFee := actualFee - int64(expectedFee)
+	require.LessOrEqual(t, overpaidFee, int64(maxOverpayment))
+
+	t.Logf("Correct fee of %d sats", actualFee)
+}
+
 // WaitForBatchState polls until the planter has reached the desired state with
 // the given batch.
 func WaitForBatchState(t *testing.T, ctx context.Context,

itest/fee_estimation_test.go

@@ -0,0 +1,181 @@
+package itest
+
+import (
+	"context"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/taproot-assets/taprpc"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
+	"github.com/stretchr/testify/require"
+)
+
+// testFeeEstimation tests that we're able to spend outputs of various script
+// types, and that the fee estimator and TX size estimator used during asset
+// transfers are accurate.
+func testFeeEstimation(t *harnessTest) {
+	var (
+		// Make a ladder of UTXO values so use order is deterministic.
+		anchorAmounts = []int64{10000, 9990, 9980, 9970}
+
+		// The default feerate in the itests is 12.5 sat/vB, but we
+		// define it here explicitly to use for assertions.
+		defaultFeeRate   = chainfee.SatPerKWeight(3125)
+		higherFeeRate    = defaultFeeRate * 2
+		excessiveFeeRate = defaultFeeRate * 8
+		lowFeeRate       = chainfee.SatPerKWeight(500)
+
+		// We will mint assets using the largest NP2WKH output, and then
+		// use all three output types for transfers.
+		initialUTXOs = []*UTXORequest{
+			{
+				Type:   lnrpc.AddressType_NESTED_PUBKEY_HASH,
+				Amount: anchorAmounts[0],
+			},
+			{
+				Type:   lnrpc.AddressType_NESTED_PUBKEY_HASH,
+				Amount: anchorAmounts[1],
+			},
+			{
+				Type:   lnrpc.AddressType_WITNESS_PUBKEY_HASH,
+				Amount: anchorAmounts[2],
+			},
+			{
+				Type:   lnrpc.AddressType_TAPROOT_PUBKEY,
+				Amount: anchorAmounts[3],
+			},
+		}
+	)
+
+	ctxb := context.Background()
+	ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout)
+	defer cancel()
+
+	// Set the initial state of the wallet of the first node. The wallet
+	// state will reset at the end of this test.
+	SetNodeUTXOs(t, t.lndHarness.Alice, btcutil.Amount(1), initialUTXOs)
+	defer ResetNodeWallet(t, t.lndHarness.Alice)
+
+	// Mint some assets with a NP2WPKH input, which will give us an anchor
+	// output to spend for a transfer.
+	rpcAssets := MintAssetsConfirmBatch(
+		t.t, t.lndHarness.Miner.Client, t.tapd, simpleAssets,
+	)
+
+	// Check the final fee rate of the mint TX.
+	rpcMintOutpoint := rpcAssets[0].ChainAnchor.AnchorOutpoint
+	mintOutpoint, err := wire.NewOutPointFromString(rpcMintOutpoint)
+	require.NoError(t.t, err)
+
+	// We check the minting TX with a rounded fee rate as the minter does
+	// not adjust the fee rate of the TX after it was funded by our backing
+	// wallet.
+	AssertFeeRate(
+		t.t, t.lndHarness.Miner.Client, anchorAmounts[0],
+		&mintOutpoint.Hash, defaultFeeRate, true,
+	)
+
+	// Split the normal asset to create a transfer with two anchor outputs.
+	normalAssetId := rpcAssets[0].AssetGenesis.AssetId
+	splitAmount := rpcAssets[0].Amount / 2
+	addr, err := t.tapd.NewAddr(
+		ctxt, &taprpc.NewAddrRequest{
+			AssetId: normalAssetId,
+			Amt:     splitAmount,
+		},
+	)
+	require.NoError(t.t, err)
+
+	AssertAddrCreated(t.t, t.tapd, rpcAssets[0], addr)
+	sendResp := sendAssetsToAddr(t, t.tapd, addr)
+
+	transferIdx := 0
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner.Client, t.tapd, sendResp, normalAssetId,
+		[]uint64{splitAmount, splitAmount}, transferIdx, transferIdx+1,
+	)
+	transferIdx += 1
+	AssertNonInteractiveRecvComplete(t.t, t.tapd, transferIdx)
+
+	sendInputAmt := anchorAmounts[1] + 1000
+	AssertTransferFeeRate(
+		t.t, t.lndHarness.Miner.Client, sendResp, sendInputAmt,
+		defaultFeeRate, false,
+	)
+
+	// Double the fee rate to 25 sat/vB before performing another transfer.
+	t.lndHarness.SetFeeEstimateWithConf(higherFeeRate, 6)
+
+	secondSplitAmount := splitAmount / 2
+	addr2, err := t.tapd.NewAddr(
+		ctxt, &taprpc.NewAddrRequest{
+			AssetId: normalAssetId,
+			Amt:     secondSplitAmount,
+		},
+	)
+	require.NoError(t.t, err)
+
+	AssertAddrCreated(t.t, t.tapd, rpcAssets[0], addr2)
+	sendResp = sendAssetsToAddr(t, t.tapd, addr2)
+
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner.Client, t.tapd, sendResp, normalAssetId,
+		[]uint64{secondSplitAmount, secondSplitAmount},
+		transferIdx, transferIdx+1,
+	)
+	transferIdx += 1
+	AssertNonInteractiveRecvComplete(t.t, t.tapd, transferIdx)
+
+	sendInputAmt = anchorAmounts[2] + 1000
+	AssertTransferFeeRate(
+		t.t, t.lndHarness.Miner.Client, sendResp, sendInputAmt,
+		higherFeeRate, false,
+	)
+
+	// If we quadruple the fee rate, the freighter should fail during input
+	// selection.
+	t.lndHarness.SetFeeEstimateWithConf(excessiveFeeRate, 6)
+
+	thirdSplitAmount := splitAmount / 4
+	addr3, err := t.tapd.NewAddr(
+		ctxt, &taprpc.NewAddrRequest{
+			AssetId: normalAssetId,
+			Amt:     thirdSplitAmount,
+		},
+	)
+	require.NoError(t.t, err)
+
+	AssertAddrCreated(t.t, t.tapd, rpcAssets[0], addr3)
+	_, err = t.tapd.SendAsset(ctxt, &taprpc.SendAssetRequest{
+		TapAddrs: []string{addr3.Encoded},
+	})
+	require.ErrorContains(t.t, err, "insufficient funds available")
+
+	// The transfer should also be rejected if the manually-specified
+	// feerate fails the sanity check against the fee estimator's fee floor
+	// of 253 sat/kw, or 1.012 sat/vB.
+	_, err = t.tapd.SendAsset(ctxt, &taprpc.SendAssetRequest{
+		TapAddrs: []string{addr3.Encoded},
+		FeeRate:  uint32(chainfee.FeePerKwFloor) - 1,
+	})
+	require.ErrorContains(t.t, err, "manual fee rate below floor")
+	// After failure at the high feerate, we should still be able to make a
+	// transfer at a very low feerate.
+	t.lndHarness.SetFeeEstimateWithConf(lowFeeRate, 6)
+	sendResp = sendAssetsToAddr(t, t.tapd, addr3)
+
+	ConfirmAndAssertOutboundTransfer(
+		t.t, t.lndHarness.Miner.Client, t.tapd, sendResp, normalAssetId,
+		[]uint64{thirdSplitAmount, thirdSplitAmount},
+		transferIdx, transferIdx+1,
+	)
+	transferIdx += 1
+	AssertNonInteractiveRecvComplete(t.t, t.tapd, transferIdx)
+
+	sendInputAmt = anchorAmounts[3] + 1000
+	AssertTransferFeeRate(
+		t.t, t.lndHarness.Miner.Client, sendResp, sendInputAmt,
+		lowFeeRate, false,
+	)
+}

itest/test_list_on_test.go

@@ -183,6 +183,10 @@ var testCases = []*testCase{
 		name: "universe federation",
 		test: testUniverseFederation,
 	},
+	{
+		name: "fee estimation",
+		test: testFeeEstimation,
+	},
 	{
 		name: "get info",
 		test: testGetInfo,

itest/utils.go

@@ -12,11 +12,15 @@ import (
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/rpcclient"
+	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/asset"
+	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/taprpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/mintrpc"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lntest/node"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/proto"
 )
@@ -148,6 +152,73 @@ func MineBlocks(t *testing.T, client *rpcclient.Client,
 	return blocks
 }
 
+type UTXORequest struct {
+	Type   lnrpc.AddressType
+	Amount int64
+}
+
+// SetNodeUTXOs sets the wallet state for the given node wallet to a set of
+// UTXOs of a specific type and value.
+func SetNodeUTXOs(t *harnessTest, wallet *node.HarnessNode,
+	feeRate btcutil.Amount, reqs []*UTXORequest) {
+
+	minerAddr := t.lndHarness.Miner.NewMinerAddress()
+
+	// Drain any funds held by the node.
+	wallet.RPC.SendCoins(&lnrpc.SendCoinsRequest{
+		Addr:    minerAddr.EncodeAddress(),
+		SendAll: true,
+	})
+	t.lndHarness.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Build TXOs from the UTXO requests, which will be used by the miner
+	// to build a TX.
+	makeOutputs := func(req *UTXORequest) *wire.TxOut {
+		addrResp := wallet.RPC.NewAddress(
+			&lnrpc.NewAddressRequest{
+				Type: req.Type,
+			},
+		)
+
+		addr, err := btcutil.DecodeAddress(
+			addrResp.Address, t.lndHarness.Miner.ActiveNet,
+		)
+		require.NoError(t.t, err)
+
+		addrScript, err := txscript.PayToAddrScript(addr)
+		require.NoError(t.t, err)
+
+		return &wire.TxOut{
+			PkScript: addrScript,
+			Value:    req.Amount,
+		}
+	}
+
+	aliceOutputs := fn.Map(reqs, makeOutputs)
+
+	_ = t.lndHarness.Miner.SendOutputsWithoutChange(aliceOutputs, feeRate)
+	t.lndHarness.MineBlocksAndAssertNumTxes(1, 1)
+	t.lndHarness.WaitForBlockchainSync(wallet)
+}
+
+// ResetNodeWallet sets the wallet state of the given node to own 100 P2TR UTXOs
+// of BTC, which matches the wallet state when initializing the itest harness.
+func ResetNodeWallet(t *harnessTest, wallet *node.HarnessNode) {
+	const outputCount = 100
+	const txoType = lnrpc.AddressType_TAPROOT_PUBKEY
+	const outputValue = 1e8
+
+	resetReqs := make([]*UTXORequest, outputCount)
+	for i := 0; i < outputCount; i++ {
+		resetReqs[i] = &UTXORequest{
+			txoType,
+			outputValue,
+		}
+	}
+
+	SetNodeUTXOs(t, wallet, btcutil.Amount(1), resetReqs)
+}
+
 type MintOption func(*MintOptions)
 
 type MintOptions struct {