[wip]itest: add itest

Author: bhandras

itest/lnd_wallet.go

@@ -1,11 +1,21 @@
 package itest
 
 import (
+	"bytes"
+
 	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/lightningnetwork/lnd/lntest/node"
 	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/stretchr/testify/require"
 )
 
@@ -48,6 +58,12 @@ var walletTestCases = []*lntest.TestCase{
 			runTestListUnspentRestart(ht, ht.FundCoinsP2TR)
 		},
 	},
+	{
+		Name: "submit package basic",
+		TestFunc: func(ht *lntest.HarnessTest) {
+			runTestSubmitPackageBasicCPFP(ht)
+		},
+	},
 }
 
 type fundMethod func(amt btcutil.Amount, hn *node.HarnessNode) *wire.MsgTx
@@ -118,3 +134,243 @@ func runTestListUnspentRestart(ht *lntest.HarnessTest, fundCoins fundMethod) {
 	// Alice should have no UTXO.
 	ht.AssertNumUTXOs(alice, 0)
 }
+
+// Helper to convert walletrpc.KeyDescriptor to a P2WPKH address.
+func keyDescToAddrP2WPKH(ht *lntest.HarnessTest,
+	keyDesc *signrpc.KeyDescriptor) btcutil.Address {
+
+	harnessNetParams := &chaincfg.RegressionNetParams
+
+	pubKeyBytes := keyDesc.RawKeyBytes
+	require.NotEmpty(ht, pubKeyBytes, "KeyDescriptor has empty RawKeyBytes")
+
+	addr, err := btcutil.NewAddressWitnessPubKeyHash(
+		btcutil.Hash160(pubKeyBytes),
+		harnessNetParams,
+	)
+	require.NoError(ht, err)
+
+	return addr
+}
+
+// runTestSubmitPackageBasicCPFP tests the SubmitPackage RPC for a simple
+// Child-Pays-For-Parent (CPFP) scenario.
+func runTestSubmitPackageBasicCPFP(ht *lntest.HarnessTest) {
+	const (
+		fundingAmount = btcutil.Amount(10_000_000)
+		childFeeRate  = 100
+		testKeyFamily = 111
+	)
+
+	// Create a new node (Alice).
+	alice := ht.NewNode("Alice", nil)
+	defer ht.Shutdown(alice)
+
+	// Fund Alice with a UTXO.
+	ht.FundCoins(fundingAmount*2, alice)
+
+	// Derive a key and address for the initial funding.
+	fundingKey := alice.RPC.DeriveNextKey(
+		&walletrpc.KeyReq{
+			KeyFamily: testKeyFamily,
+		},
+	)
+
+	fundingAddr := keyDescToAddrP2WPKH(ht, fundingKey)
+	ht.Logf("Funding address: %s", fundingAddr)
+
+	// Send funds to this specific address.
+	ht.SendCoinsToAddr(alice, fundingAddr, fundingAmount)
+	block := ht.MineBlocksAndAssertNumTxes(1, 1)
+
+	// Now find the funding tx in the mined block so we can use the output
+	// as an input to the parent tx.
+	fundingPkScript := ht.PayToAddrScript(fundingAddr)
+	var (
+		fundingOutIndex uint32
+		fundingOut      *wire.TxOut
+		fundingTx       *wire.MsgTx
+	)
+
+	for _, tx := range block[0].Transactions {
+		for i, txOut := range tx.TxOut {
+			if bytes.Equal(txOut.PkScript, fundingPkScript) {
+				fundingTx = tx
+				fundingOut = txOut
+				fundingOutIndex = uint32(i)
+
+				break
+			}
+		}
+	}
+	require.NotNil(ht, fundingTx, "Funding output not found")
+
+	fundOutPoint := wire.OutPoint{
+		Hash:  fundingTx.TxHash(),
+		Index: fundingOutIndex,
+	}
+
+	parentOutValue := int64(fundingAmount)
+
+	// Create a V3 "parent" transaction spending the funding output.
+	parentTx := wire.NewMsgTx(3)
+	parentTx.AddTxIn(wire.NewTxIn(&fundOutPoint, nil, nil))
+
+	// Derive a key and address for the parent's output.
+	parentOutKey := alice.RPC.DeriveNextKey(
+		&walletrpc.KeyReq{
+			KeyFamily: testKeyFamily,
+		},
+	)
+
+	parentOutAddr := keyDescToAddrP2WPKH(ht, parentOutKey)
+	parentOutPkScript := ht.PayToAddrScript(parentOutAddr)
+	parentTx.AddTxOut(wire.NewTxOut(parentOutValue, parentOutPkScript))
+
+	// Serialize the parent tx.
+	var parentBuf bytes.Buffer
+	require.NoError(ht, parentTx.Serialize(&parentBuf))
+
+	// Create a sign descriptor for the parent tx.
+	parentSignDesc := &signrpc.SignDescriptor{
+		KeyDesc: fundingKey,
+		Output: &signrpc.TxOut{
+			Value:    fundingOut.Value,
+			PkScript: fundingOut.PkScript,
+		},
+		Sighash:       uint32(txscript.SigHashAll),
+		WitnessScript: fundingOut.PkScript,
+		SignMethod:    signrpc.SignMethod_SIGN_METHOD_WITNESS_V0,
+	}
+
+	// Sign the parent tx.
+	parentSignResp, err := alice.RPC.Signer.SignOutputRaw(
+		ht.Context(),
+		&signrpc.SignReq{
+			RawTxBytes: parentBuf.Bytes(),
+			SignDescs: []*signrpc.SignDescriptor{
+				parentSignDesc,
+			},
+		},
+	)
+	require.NoError(ht, err)
+
+	// Set the parent tx's witness to the signature.
+	parentTx.TxIn[0].Witness = makeP2WPKHWitness(
+		parentSignResp.RawSigs[0], fundingKey,
+	)
+
+	// Reserialize the parent after the witness has been set.
+	parentBuf.Reset()
+	require.NoError(ht, parentTx.Serialize(&parentBuf))
+
+	parentOut := &wire.OutPoint{
+		Hash:  parentTx.TxHash(),
+		Index: 0,
+	}
+
+	// Create a new P2WPKH address for the child's output.
+	childOutAddrResp := alice.RPC.NewAddress(
+		&lnrpc.NewAddressRequest{
+			Account: lnwallet.DefaultAccountName,
+			Type:    lnrpc.AddressType_WITNESS_PUBKEY_HASH,
+		},
+	)
+	require.NoError(ht, err)
+
+	// Estimate child's weight and fee.
+	childEstimator := input.TxWeightEstimator{}
+	childEstimator.AddP2WKHInput()
+	childEstimator.AddP2WKHOutput()
+	childWeight := childEstimator.Weight()
+	childFee := chainfee.SatPerVByte(
+		childFeeRate,
+	).FeePerKWeight().FeeForWeight(
+		childWeight,
+	)
+
+	childOutValue := btcutil.Amount(parentOutValue) - childFee
+
+	// Create the unsigned child transaction spending the parent's output.
+	childTx := wire.NewMsgTx(3)
+	childTx.AddTxIn(wire.NewTxIn(parentOut, nil, nil))
+
+	childOutAddr := ht.DecodeAddress(childOutAddrResp.Address)
+	childOutPkScript := ht.PayToAddrScript(childOutAddr)
+
+	childTx.AddTxOut(
+		wire.NewTxOut(int64(childOutValue), childOutPkScript),
+	)
+
+	// Serialize the child tx.
+	var childBuf bytes.Buffer
+	require.NoError(ht, childTx.Serialize(&childBuf))
+
+	// Create a sign descriptor for the child tx.
+	childSignDesc := &signrpc.SignDescriptor{
+		KeyDesc: parentOutKey,
+		Output: &signrpc.TxOut{
+			Value:    parentOutValue,
+			PkScript: parentOutPkScript,
+		},
+		Sighash:       uint32(txscript.SigHashAll),
+		WitnessScript: parentOutPkScript,
+		SignMethod:    signrpc.SignMethod_SIGN_METHOD_WITNESS_V0,
+	}
+
+	// Sign the child tx.
+	childSignResp, err := alice.RPC.Signer.SignOutputRaw(
+		ht.Context(),
+		&signrpc.SignReq{
+			RawTxBytes: childBuf.Bytes(),
+			SignDescs: []*signrpc.SignDescriptor{
+				childSignDesc,
+			},
+		},
+	)
+	require.NoError(ht, err)
+
+	// Set the child tx's witness to the signature.
+	childTx.TxIn[0].Witness = makeP2WPKHWitness(
+		childSignResp.RawSigs[0], parentOutKey,
+	)
+
+	// Reserialize the child after the witness has been set.
+	childBuf.Reset()
+	require.NoError(ht, childTx.Serialize(&childBuf))
+
+	submitPackageResp, err := alice.RPC.WalletKit.SubmitPackage(
+		ht.Context(), &walletrpc.SubmitPackageRequest{
+			ParentTxs: [][]byte{parentBuf.Bytes()},
+			ChildTx:   childBuf.Bytes(),
+		},
+	)
+	require.NoError(ht, err)
+	ht.Logf("SubmitPackage response: %v", spew.Sdump(submitPackageResp))
+
+	// TODO(bhandras): once we have package support for btcd or we switch
+	// to bitcoind miner in the tests we can uncomment the following lines
+	// and test the package transactions in the mempool and mined blocks.
+	/*
+		ht.AssertTxInMempool(parentTx.TxHash())
+		ht.AssertTxInMempool(childTx.TxHash())
+
+		ht.Log("Mining block with package transactions...")
+		block = ht.MineBlocksAndAssertNumTxes(1, 2)
+		ht.AssertTxInBlock(block[0], parentTx.TxHash())
+		ht.AssertTxInBlock(block[0], childTx.TxHash())
+	*/
+}
+
+// makeP2WPKHWitness creates a P2WPKH witness stack for the given signature and
+// key descriptor.
+func makeP2WPKHWitness(sig []byte,
+	keyDesc *signrpc.KeyDescriptor) wire.TxWitness {
+
+	sigWithHash := append(sig, byte(txscript.SigHashAll))
+
+	return wire.TxWitness{
+		sigWithHash,         // element 0: 70-73-byte signature.
+		keyDesc.RawKeyBytes, // element 1: 33-byte compressed pubkey.
+	}
+}

lntest/harness.go

@@ -1419,6 +1419,13 @@ func (h *HarnessTest) IsNeutrinoBackend() bool {
 	return h.manager.chainBackend.Name() == NeutrinoBackendName
 }
 
+// IsBitcoindBackend returns a bool indicating whether the node is using a
+// bitcoind as its backend. This is useful when we want to only run certain
+// tests with a bitcoind backend.
+func (h *HarnessTest) IsBitcoindBackend() bool {
+	return h.manager.chainBackend.Name() == BitcoindBackendName
+}
+
 // fundCoins attempts to send amt satoshis from the internal mining node to the
 // targeted lightning node. The confirmed boolean indicates whether the
 // transaction that pays to the target should confirm. For neutrino backend,
@@ -2282,6 +2289,24 @@ func (h *HarnessTest) SendCoins(a, b *node.HarnessNode,
 	return tx
 }
 
+// SendCoinsToAddr sends the given amount from the passed node to the given
+// address amount, returns the sending tx.
+func (h *HarnessTest) SendCoinsToAddr(node *node.HarnessNode,
+	addr btcutil.Address, amt btcutil.Amount) *wire.MsgTx {
+
+	// Send the coins to the given address. We should expect a tx to be
+	// broadcast and seen in the mempool.
+	sendReq := &lnrpc.SendCoinsRequest{
+		Addr:       addr.String(),
+		Amount:     int64(amt),
+		TargetConf: 6,
+	}
+	node.RPC.SendCoins(sendReq)
+	tx := h.GetNumTxsFromMempool(1)[0]
+
+	return tx
+}
+
 // SendCoins sends all coins from node A to node B, returns the sending tx.
 func (h *HarnessTest) SendAllCoins(a, b *node.HarnessNode) *wire.MsgTx {
 	// Create an address for Bob receive the coins.

lntest/utils.go

@@ -23,6 +23,9 @@ const (
 	// NeutrinoBackendName is the name of the neutrino backend.
 	NeutrinoBackendName = "neutrino"
 
+	// BitcoindBackendName is the name of the bitcoind backend.
+	BitcoindBackendName = "bitcoind"
+
 	DefaultTimeout = wait.DefaultTimeout
 
 	// noFeeLimitMsat is used to specify we will put no requirements on fee