itest+lntest: migrate lntemp to lntest

This commit performs the takeover that `lntemp` is now promoted to be
`lntest`, and the scaffolding is now removed as all the refactoring is
finished!

lntest/rpc/chain_kit.go

@@ -0,0 +1,64 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc/chainrpc"
+)
+
+// =====================
+// ChainKitClient related RPCs.
+// =====================
+
+// GetBestBlock makes an RPC call to chain kit client's GetBestBlock and
+// asserts.
+func (h *HarnessRPC) GetBestBlock(
+	req *chainrpc.GetBestBlockRequest) *chainrpc.GetBestBlockResponse {
+
+	if req == nil {
+		req = &chainrpc.GetBestBlockRequest{}
+	}
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.ChainKit.GetBestBlock(ctxt, req)
+	h.NoError(err, "GetBestBlock")
+
+	return resp
+}
+
+// GetBlock makes an RPC call to chain kit client's GetBlock and asserts.
+func (h *HarnessRPC) GetBlock(
+	req *chainrpc.GetBlockRequest) *chainrpc.GetBlockResponse {
+
+	if req == nil {
+		req = &chainrpc.GetBlockRequest{}
+	}
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.ChainKit.GetBlock(ctxt, req)
+	h.NoError(err, "GetBlock")
+
+	return resp
+}
+
+// GetBlockHash makes an RPC call to chain kit client's GetBlockHash and
+// asserts.
+func (h *HarnessRPC) GetBlockHash(
+	req *chainrpc.GetBlockHashRequest) *chainrpc.GetBlockHashResponse {
+
+	if req == nil {
+		req = &chainrpc.GetBlockHashRequest{}
+	}
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.ChainKit.GetBlockHash(ctxt, req)
+	h.NoError(err, "GetBlockHash")
+
+	return resp
+}

lntest/rpc/chain_notifier.go

@@ -0,0 +1,44 @@
+package rpc
+
+import (
+	"github.com/lightningnetwork/lnd/lnrpc/chainrpc"
+)
+
+// =====================
+// ChainClient related RPCs.
+// =====================
+
+type ConfNtfnClient chainrpc.ChainNotifier_RegisterConfirmationsNtfnClient
+
+// RegisterConfirmationsNtfn creates a notification client to watch a given
+// transaction being confirmed.
+func (h *HarnessRPC) RegisterConfirmationsNtfn(
+	req *chainrpc.ConfRequest) ConfNtfnClient {
+
+	// RegisterConfirmationsNtfn needs to have the context alive for the
+	// entire test case as the returned client will be used for send and
+	// receive events stream. Thus we use runCtx here instead of a timeout
+	// context.
+	client, err := h.ChainClient.RegisterConfirmationsNtfn(
+		h.runCtx, req,
+	)
+	h.NoError(err, "RegisterConfirmationsNtfn")
+
+	return client
+}
+
+type SpendClient chainrpc.ChainNotifier_RegisterSpendNtfnClient
+
+// RegisterSpendNtfn creates a notification client to watch a given
+// transaction being spent.
+func (h *HarnessRPC) RegisterSpendNtfn(req *chainrpc.SpendRequest) SpendClient {
+	// RegisterSpendNtfn needs to have the context alive for the entire
+	// test case as the returned client will be used for send and receive
+	// events stream. Thus we use runCtx here instead of a timeout context.
+	client, err := h.ChainClient.RegisterSpendNtfn(
+		h.runCtx, req,
+	)
+	h.NoError(err, "RegisterSpendNtfn")
+
+	return client
+}

lntest/rpc/harness_rpc.go

@@ -0,0 +1,98 @@
+package rpc
+
+import (
+	"context"
+	"testing"
+
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/chainrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/neutrinorpc"
+	"github.com/lightningnetwork/lnd/lnrpc/peersrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/watchtowerrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/wtclientrpc"
+	"github.com/lightningnetwork/lnd/lntest/wait"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc"
+)
+
+const (
+	DefaultTimeout = wait.DefaultTimeout
+)
+
+// HarnessRPC wraps all lnd's RPC clients into a single struct for easier
+// access.
+type HarnessRPC struct {
+	*testing.T
+
+	LN               lnrpc.LightningClient
+	WalletUnlocker   lnrpc.WalletUnlockerClient
+	Invoice          invoicesrpc.InvoicesClient
+	Signer           signrpc.SignerClient
+	Router           routerrpc.RouterClient
+	WalletKit        walletrpc.WalletKitClient
+	Watchtower       watchtowerrpc.WatchtowerClient
+	WatchtowerClient wtclientrpc.WatchtowerClientClient
+	State            lnrpc.StateClient
+	ChainClient      chainrpc.ChainNotifierClient
+	ChainKit         chainrpc.ChainKitClient
+	NeutrinoKit      neutrinorpc.NeutrinoKitClient
+	Peer             peersrpc.PeersClient
+
+	// Name is the HarnessNode's name.
+	Name string
+
+	// runCtx is a context with cancel method. It's used to signal when the
+	// node needs to quit, and used as the parent context when spawning
+	// children contexts for RPC requests.
+	runCtx context.Context
+	cancel context.CancelFunc
+}
+
+// NewHarnessRPC creates a new HarnessRPC with its own context inherted from
+// the pass context.
+func NewHarnessRPC(ctxt context.Context, t *testing.T, c *grpc.ClientConn,
+	name string) *HarnessRPC {
+
+	h := &HarnessRPC{
+		T:                t,
+		LN:               lnrpc.NewLightningClient(c),
+		Invoice:          invoicesrpc.NewInvoicesClient(c),
+		Router:           routerrpc.NewRouterClient(c),
+		WalletKit:        walletrpc.NewWalletKitClient(c),
+		WalletUnlocker:   lnrpc.NewWalletUnlockerClient(c),
+		Watchtower:       watchtowerrpc.NewWatchtowerClient(c),
+		WatchtowerClient: wtclientrpc.NewWatchtowerClientClient(c),
+		Signer:           signrpc.NewSignerClient(c),
+		State:            lnrpc.NewStateClient(c),
+		ChainClient:      chainrpc.NewChainNotifierClient(c),
+		ChainKit:         chainrpc.NewChainKitClient(c),
+		NeutrinoKit:      neutrinorpc.NewNeutrinoKitClient(c),
+		Peer:             peersrpc.NewPeersClient(c),
+		Name:             name,
+	}
+
+	// Inherit parent context.
+	h.runCtx, h.cancel = context.WithCancel(ctxt)
+	return h
+}
+
+// MakeOutpoint returns the outpoint of the channel's funding transaction.
+func (h *HarnessRPC) MakeOutpoint(cp *lnrpc.ChannelPoint) wire.OutPoint {
+	fundingTxID, err := lnrpc.GetChanPointFundingTxid(cp)
+	require.NoErrorf(h, err, "failed to make chanPoint", h.Name)
+
+	return wire.OutPoint{
+		Hash:  *fundingTxID,
+		Index: cp.OutputIndex,
+	}
+}
+
+// NoError is a helper method to format the error message used in calling RPCs.
+func (h *HarnessRPC) NoError(err error, operation string) {
+	require.NoErrorf(h, err, "%s: failed to call %s", h.Name, operation)
+}

lntest/rpc/invoices.go

@@ -0,0 +1,101 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
+)
+
+// =====================
+// InvoiceClient related RPCs.
+// =====================
+
+// LookupInvoiceV2 queries the node's invoices using the invoice client's
+// LookupInvoiceV2.
+func (h *HarnessRPC) LookupInvoiceV2(
+	req *invoicesrpc.LookupInvoiceMsg) *lnrpc.Invoice {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Invoice.LookupInvoiceV2(ctxt, req)
+	h.NoError(err, "LookupInvoiceV2")
+
+	return resp
+}
+
+// AddHoldInvoice adds a hold invoice for the given node and asserts.
+func (h *HarnessRPC) AddHoldInvoice(
+	r *invoicesrpc.AddHoldInvoiceRequest) *invoicesrpc.AddHoldInvoiceResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	invoice, err := h.Invoice.AddHoldInvoice(ctxt, r)
+	h.NoError(err, "AddHoldInvoice")
+
+	return invoice
+}
+
+// SettleInvoice settles a given invoice and asserts.
+func (h *HarnessRPC) SettleInvoice(
+	preimage []byte) *invoicesrpc.SettleInvoiceResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &invoicesrpc.SettleInvoiceMsg{Preimage: preimage}
+	resp, err := h.Invoice.SettleInvoice(ctxt, req)
+	h.NoError(err, "SettleInvoice")
+
+	return resp
+}
+
+// CancelInvoice cancels a given invoice and asserts.
+func (h *HarnessRPC) CancelInvoice(
+	payHash []byte) *invoicesrpc.CancelInvoiceResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &invoicesrpc.CancelInvoiceMsg{PaymentHash: payHash}
+	resp, err := h.Invoice.CancelInvoice(ctxt, req)
+	h.NoError(err, "CancelInvoice")
+
+	return resp
+}
+
+type SingleInvoiceClient invoicesrpc.Invoices_SubscribeSingleInvoiceClient
+
+// SubscribeSingleInvoice creates a subscription client for given invoice and
+// asserts its creation.
+func (h *HarnessRPC) SubscribeSingleInvoice(rHash []byte) SingleInvoiceClient {
+	req := &invoicesrpc.SubscribeSingleInvoiceRequest{RHash: rHash}
+
+	// SubscribeSingleInvoice needs to have the context alive for the
+	// entire test case as the returned client will be used for send and
+	// receive events stream. Thus we use runCtx here instead of a timeout
+	// context.
+	client, err := h.Invoice.SubscribeSingleInvoice(h.runCtx, req)
+	h.NoError(err, "SubscribeSingleInvoice")
+
+	return client
+}
+
+type TrackPaymentClient routerrpc.Router_TrackPaymentV2Client
+
+// TrackPaymentV2 creates a subscription client for given invoice and
+// asserts its creation.
+func (h *HarnessRPC) TrackPaymentV2(payHash []byte) TrackPaymentClient {
+	req := &routerrpc.TrackPaymentRequest{PaymentHash: payHash}
+
+	// TrackPaymentV2 needs to have the context alive for the entire test
+	// case as the returned client will be used for send and receive events
+	// stream. Thus we use runCtx here instead of a timeout context.
+	client, err := h.Router.TrackPaymentV2(h.runCtx, req)
+	h.NoError(err, "TrackPaymentV2")
+
+	return client
+}

lntest/rpc/lnd.go

@@ -0,0 +1,684 @@
+package rpc
+
+import (
+	"context"
+	"strings"
+
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/stretchr/testify/require"
+)
+
+// =====================
+// LightningClient related RPCs.
+// =====================
+
+// NewAddress makes a RPC call to NewAddress and asserts.
+func (h *HarnessRPC) NewAddress(
+	req *lnrpc.NewAddressRequest) *lnrpc.NewAddressResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.NewAddress(ctxt, req)
+	h.NoError(err, "NewAddress")
+
+	return resp
+}
+
+// WalletBalance makes a RPC call to WalletBalance and asserts.
+func (h *HarnessRPC) WalletBalance() *lnrpc.WalletBalanceResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.WalletBalanceRequest{}
+	resp, err := h.LN.WalletBalance(ctxt, req)
+	h.NoError(err, "WalletBalance")
+
+	return resp
+}
+
+// ListPeers makes a RPC call to the node's ListPeers and asserts.
+func (h *HarnessRPC) ListPeers() *lnrpc.ListPeersResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.ListPeers(ctxt, &lnrpc.ListPeersRequest{})
+	h.NoError(err, "ListPeers")
+
+	return resp
+}
+
+// DisconnectPeer calls the DisconnectPeer RPC on a given node with a specified
+// public key string and asserts there's no error.
+func (h *HarnessRPC) DisconnectPeer(
+	pubkey string) *lnrpc.DisconnectPeerResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.DisconnectPeerRequest{PubKey: pubkey}
+
+	resp, err := h.LN.DisconnectPeer(ctxt, req)
+	h.NoError(err, "DisconnectPeer")
+
+	return resp
+}
+
+// DeleteAllPayments makes a RPC call to the node's DeleteAllPayments and
+// asserts.
+func (h *HarnessRPC) DeleteAllPayments() {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.DeleteAllPaymentsRequest{}
+	_, err := h.LN.DeleteAllPayments(ctxt, req)
+	h.NoError(err, "DeleteAllPayments")
+}
+
+// GetInfo calls the GetInfo RPC on a given node and asserts there's no error.
+func (h *HarnessRPC) GetInfo() *lnrpc.GetInfoResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	info, err := h.LN.GetInfo(ctxt, &lnrpc.GetInfoRequest{})
+	h.NoError(err, "GetInfo")
+
+	return info
+}
+
+// ConnectPeer makes a RPC call to ConnectPeer and asserts there's no error.
+func (h *HarnessRPC) ConnectPeer(
+	req *lnrpc.ConnectPeerRequest) *lnrpc.ConnectPeerResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.ConnectPeer(ctxt, req)
+	h.NoError(err, "ConnectPeer")
+
+	return resp
+}
+
+// ConnectPeerAssertErr makes a RPC call to ConnectPeer and asserts an error
+// returned.
+func (h *HarnessRPC) ConnectPeerAssertErr(req *lnrpc.ConnectPeerRequest) error {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.LN.ConnectPeer(ctxt, req)
+	require.Error(h, err, "expected an error from ConnectPeer")
+
+	return err
+}
+
+// ListChannels list the channels for the given node and asserts it's
+// successful.
+func (h *HarnessRPC) ListChannels(
+	req *lnrpc.ListChannelsRequest) *lnrpc.ListChannelsResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.ListChannels(ctxt, req)
+	h.NoError(err, "ListChannels")
+
+	return resp
+}
+
+// PendingChannels makes a RPC request to PendingChannels and asserts there's
+// no error.
+func (h *HarnessRPC) PendingChannels() *lnrpc.PendingChannelsResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	pendingChansRequest := &lnrpc.PendingChannelsRequest{}
+	resp, err := h.LN.PendingChannels(ctxt, pendingChansRequest)
+
+	// TODO(yy): We may get a `unable to find arbitrator` error from the
+	// rpc point, due to a timing issue in rpcserver,
+	// 1. `r.server.chanStateDB.FetchClosedChannels` fetches
+	//    the pending force close channel.
+	// 2. `r.arbitratorPopulateForceCloseResp` relies on the
+	//    channel arbitrator to get the report, and,
+	// 3. the arbitrator may be deleted due to the force close
+	//    channel being resolved.
+	// Somewhere along the line is missing a lock to keep the data
+	// consistent.
+	//
+	// Return if there's no error.
+	if err == nil {
+		return resp
+	}
+
+	// Otherwise, give it a second shot if it's the arbitrator error.
+	if strings.Contains(err.Error(), "unable to find arbitrator") {
+		resp, err = h.LN.PendingChannels(ctxt, pendingChansRequest)
+	}
+
+	// It's very unlikely we'd get the arbitrator not found error again.
+	h.NoError(err, "PendingChannels")
+
+	return resp
+}
+
+// ClosedChannels makes a RPC call to node's ClosedChannels and asserts.
+func (h *HarnessRPC) ClosedChannels(
+	req *lnrpc.ClosedChannelsRequest) *lnrpc.ClosedChannelsResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.ClosedChannels(ctxt, req)
+	h.NoError(err, "ClosedChannels")
+
+	return resp
+}
+
+// ListPayments lists the node's payments and asserts.
+func (h *HarnessRPC) ListPayments(
+	req *lnrpc.ListPaymentsRequest) *lnrpc.ListPaymentsResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.ListPayments(ctxt, req)
+	h.NoError(err, "ListPayments")
+
+	return resp
+}
+
+// ListInvoices list the node's invoice using the request and asserts.
+func (h *HarnessRPC) ListInvoices(
+	req *lnrpc.ListInvoiceRequest) *lnrpc.ListInvoiceResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	if req == nil {
+		req = &lnrpc.ListInvoiceRequest{}
+	}
+
+	resp, err := h.LN.ListInvoices(ctxt, req)
+	h.NoError(err, "ListInvoice")
+
+	return resp
+}
+
+// DescribeGraph makes a RPC call to the node's DescribeGraph and asserts. It
+// takes a bool to indicate whether we want to include private edges or not.
+func (h *HarnessRPC) DescribeGraph(
+	req *lnrpc.ChannelGraphRequest) *lnrpc.ChannelGraph {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.DescribeGraph(ctxt, req)
+	h.NoError(err, "DescribeGraph")
+
+	return resp
+}
+
+// ChannelBalance gets the channel balance and asserts.
+func (h *HarnessRPC) ChannelBalance() *lnrpc.ChannelBalanceResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.ChannelBalanceRequest{}
+	resp, err := h.LN.ChannelBalance(ctxt, req)
+	h.NoError(err, "ChannelBalance")
+
+	return resp
+}
+
+type OpenChanClient lnrpc.Lightning_OpenChannelClient
+
+// OpenChannel makes a rpc call to LightningClient and returns the open channel
+// client.
+func (h *HarnessRPC) OpenChannel(req *lnrpc.OpenChannelRequest) OpenChanClient {
+	stream, err := h.LN.OpenChannel(h.runCtx, req)
+	h.NoError(err, "OpenChannel")
+
+	return stream
+}
+
+type CloseChanClient lnrpc.Lightning_CloseChannelClient
+
+// CloseChannel makes a rpc call to LightningClient and returns the close
+// channel client.
+func (h *HarnessRPC) CloseChannel(
+	req *lnrpc.CloseChannelRequest) CloseChanClient {
+
+	// Use runCtx here instead of a timeout context to keep the client
+	// alive for the entire test case.
+	stream, err := h.LN.CloseChannel(h.runCtx, req)
+	h.NoError(err, "CloseChannel")
+
+	return stream
+}
+
+// FundingStateStep makes a RPC call to FundingStateStep and asserts.
+func (h *HarnessRPC) FundingStateStep(
+	msg *lnrpc.FundingTransitionMsg) *lnrpc.FundingStateStepResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.FundingStateStep(ctxt, msg)
+	h.NoError(err, "FundingStateStep")
+
+	return resp
+}
+
+// FundingStateStepAssertErr makes a RPC call to FundingStateStep and asserts
+// there's an error.
+func (h *HarnessRPC) FundingStateStepAssertErr(m *lnrpc.FundingTransitionMsg) {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.LN.FundingStateStep(ctxt, m)
+	require.Error(h, err, "expected an error from FundingStateStep")
+}
+
+// AddInvoice adds a invoice for the given node and asserts.
+func (h *HarnessRPC) AddInvoice(req *lnrpc.Invoice) *lnrpc.AddInvoiceResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	invoice, err := h.LN.AddInvoice(ctxt, req)
+	h.NoError(err, "AddInvoice")
+
+	return invoice
+}
+
+// AbandonChannel makes a RPC call to AbandonChannel and asserts.
+func (h *HarnessRPC) AbandonChannel(
+	req *lnrpc.AbandonChannelRequest) *lnrpc.AbandonChannelResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.AbandonChannel(ctxt, req)
+	h.NoError(err, "AbandonChannel")
+
+	return resp
+}
+
+// ExportAllChanBackups makes a RPC call to the node's ExportAllChannelBackups
+// and asserts.
+func (h *HarnessRPC) ExportAllChanBackups() *lnrpc.ChanBackupSnapshot {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.ChanBackupExportRequest{}
+	chanBackup, err := h.LN.ExportAllChannelBackups(ctxt, req)
+	h.NoError(err, "ExportAllChannelBackups")
+
+	return chanBackup
+}
+
+// ExportChanBackup makes a RPC call to the node's ExportChannelBackup
+// and asserts.
+func (h *HarnessRPC) ExportChanBackup(
+	chanPoint *lnrpc.ChannelPoint) *lnrpc.ChannelBackup {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.ExportChannelBackupRequest{
+		ChanPoint: chanPoint,
+	}
+	chanBackup, err := h.LN.ExportChannelBackup(ctxt, req)
+	h.NoError(err, "ExportChannelBackup")
+
+	return chanBackup
+}
+
+// RestoreChanBackups makes a RPC call to the node's RestoreChannelBackups and
+// asserts.
+func (h *HarnessRPC) RestoreChanBackups(
+	req *lnrpc.RestoreChanBackupRequest) *lnrpc.RestoreBackupResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.RestoreChannelBackups(ctxt, req)
+	h.NoError(err, "RestoreChannelBackups")
+
+	return resp
+}
+
+type AcceptorClient lnrpc.Lightning_ChannelAcceptorClient
+
+// ChannelAcceptor makes a RPC call to the node's ChannelAcceptor and asserts.
+func (h *HarnessRPC) ChannelAcceptor() (AcceptorClient, context.CancelFunc) {
+	// Use runCtx here instead of a timeout context to keep the client
+	// alive for the entire test case.
+	ctxt, cancel := context.WithCancel(h.runCtx)
+	resp, err := h.LN.ChannelAcceptor(ctxt)
+	h.NoError(err, "ChannelAcceptor")
+
+	return resp, cancel
+}
+
+// SendCoins sends a given amount of money to the specified address from the
+// passed node.
+func (h *HarnessRPC) SendCoins(
+	req *lnrpc.SendCoinsRequest) *lnrpc.SendCoinsResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.SendCoins(ctxt, req)
+	h.NoError(err, "SendCoins")
+
+	return resp
+}
+
+// SendCoinsAssertErr sends a given amount of money to the specified address
+// from the passed node and asserts an error has returned.
+func (h *HarnessRPC) SendCoinsAssertErr(req *lnrpc.SendCoinsRequest) {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.LN.SendCoins(ctxt, req)
+	require.Error(h, err, "node %s didn't not return an error", h.Name)
+}
+
+// GetTransactions makes a RPC call to GetTransactions and asserts.
+func (h *HarnessRPC) GetTransactions(
+	req *lnrpc.GetTransactionsRequest) *lnrpc.TransactionDetails {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	if req == nil {
+		req = &lnrpc.GetTransactionsRequest{}
+	}
+
+	resp, err := h.LN.GetTransactions(ctxt, req)
+	h.NoError(err, "GetTransactions")
+
+	return resp
+}
+
+// SignMessage makes a RPC call to node's SignMessage and asserts.
+func (h *HarnessRPC) SignMessage(msg []byte) *lnrpc.SignMessageResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.SignMessageRequest{Msg: msg}
+	resp, err := h.LN.SignMessage(ctxt, req)
+	h.NoError(err, "SignMessage")
+
+	return resp
+}
+
+// VerifyMessage makes a RPC call to node's VerifyMessage and asserts.
+func (h *HarnessRPC) VerifyMessage(msg []byte,
+	sig string) *lnrpc.VerifyMessageResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &lnrpc.VerifyMessageRequest{Msg: msg, Signature: sig}
+	resp, err := h.LN.VerifyMessage(ctxt, req)
+	h.NoError(err, "VerifyMessage")
+
+	return resp
+}
+
+// GetRecoveryInfo uses the specified node to make a RPC call to
+// GetRecoveryInfo and asserts.
+func (h *HarnessRPC) GetRecoveryInfo(
+	req *lnrpc.GetRecoveryInfoRequest) *lnrpc.GetRecoveryInfoResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	if req == nil {
+		req = &lnrpc.GetRecoveryInfoRequest{}
+	}
+
+	resp, err := h.LN.GetRecoveryInfo(ctxt, req)
+	h.NoError(err, "GetRecoveryInfo")
+
+	return resp
+}
+
+// BatchOpenChannel makes a RPC call to BatchOpenChannel and asserts.
+func (h *HarnessRPC) BatchOpenChannel(
+	req *lnrpc.BatchOpenChannelRequest) *lnrpc.BatchOpenChannelResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.BatchOpenChannel(ctxt, req)
+	h.NoError(err, "BatchOpenChannel")
+
+	return resp
+}
+
+// BatchOpenChannelAssertErr makes a RPC call to BatchOpenChannel and asserts
+// there's an error returned.
+func (h *HarnessRPC) BatchOpenChannelAssertErr(
+	req *lnrpc.BatchOpenChannelRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.LN.BatchOpenChannel(ctxt, req)
+	require.Error(h, err, "expecte batch open channel fail")
+
+	return err
+}
+
+// QueryRoutes makes a RPC call to QueryRoutes and asserts.
+func (h *HarnessRPC) QueryRoutes(
+	req *lnrpc.QueryRoutesRequest) *lnrpc.QueryRoutesResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	routes, err := h.LN.QueryRoutes(ctxt, req)
+	h.NoError(err, "QueryRoutes")
+
+	return routes
+}
+
+type SendToRouteClient lnrpc.Lightning_SendToRouteClient
+
+// SendToRoute makes a RPC call to SendToRoute and asserts.
+func (h *HarnessRPC) SendToRoute() SendToRouteClient {
+	// SendToRoute needs to have the context alive for the entire test case
+	// as the returned client will be used for send and receive payment
+	// stream. Thus we use runCtx here instead of a timeout context.
+	client, err := h.LN.SendToRoute(h.runCtx)
+	h.NoError(err, "SendToRoute")
+
+	return client
+}
+
+// SendToRouteSync makes a RPC call to SendToRouteSync and asserts.
+func (h *HarnessRPC) SendToRouteSync(
+	req *lnrpc.SendToRouteRequest) *lnrpc.SendResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.SendToRouteSync(ctxt, req)
+	h.NoError(err, "SendToRouteSync")
+
+	return resp
+}
+
+// UpdateChannelPolicy makes a RPC call to UpdateChannelPolicy and asserts.
+func (h *HarnessRPC) UpdateChannelPolicy(
+	req *lnrpc.PolicyUpdateRequest) *lnrpc.PolicyUpdateResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.UpdateChannelPolicy(ctxt, req)
+	h.NoError(err, "UpdateChannelPolicy")
+
+	return resp
+}
+
+type InvoiceUpdateClient lnrpc.Lightning_SubscribeInvoicesClient
+
+// SubscribeInvoices creates a subscription client for invoice events and
+// asserts its creation.
+//
+// NOTE: make sure to subscribe an invoice as early as possible as it takes
+// some time for the lnd to create the subscription client. If an invoice is
+// added right after the subscription, it may be missed. However, if AddIndex
+// or SettleIndex is used in the request, it will be fine as a backlog will
+// always be sent.
+func (h *HarnessRPC) SubscribeInvoices(
+	req *lnrpc.InvoiceSubscription) InvoiceUpdateClient {
+
+	// SubscribeInvoices needs to have the context alive for the
+	// entire test case as the returned client will be used for send and
+	// receive events stream. Thus we use runCtx here instead of a timeout
+	// context.
+	client, err := h.LN.SubscribeInvoices(h.runCtx, req)
+	h.NoError(err, "SubscribeInvoices")
+
+	return client
+}
+
+type BackupSubscriber lnrpc.Lightning_SubscribeChannelBackupsClient
+
+// SubscribeChannelBackups creates a client to listen to channel backup stream.
+func (h *HarnessRPC) SubscribeChannelBackups() BackupSubscriber {
+	// Use runCtx here instead of timeout context to keep the stream client
+	// alive.
+	backupStream, err := h.LN.SubscribeChannelBackups(
+		h.runCtx, &lnrpc.ChannelBackupSubscription{},
+	)
+	h.NoError(err, "SubscribeChannelBackups")
+
+	return backupStream
+}
+
+// VerifyChanBackup makes a RPC call to node's VerifyChanBackup and asserts.
+func (h *HarnessRPC) VerifyChanBackup(
+	ss *lnrpc.ChanBackupSnapshot) *lnrpc.VerifyChanBackupResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.VerifyChanBackup(ctxt, ss)
+	h.NoError(err, "VerifyChanBackup")
+
+	return resp
+}
+
+// LookupInvoice queries the node's invoices using the specified rHash.
+func (h *HarnessRPC) LookupInvoice(rHash []byte) *lnrpc.Invoice {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	payHash := &lnrpc.PaymentHash{RHash: rHash}
+	resp, err := h.LN.LookupInvoice(ctxt, payHash)
+	h.NoError(err, "LookupInvoice")
+
+	return resp
+}
+
+// DecodePayReq makes a RPC call to node's DecodePayReq and asserts.
+func (h *HarnessRPC) DecodePayReq(req string) *lnrpc.PayReq {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	payReq := &lnrpc.PayReqString{PayReq: req}
+	resp, err := h.LN.DecodePayReq(ctxt, payReq)
+	h.NoError(err, "DecodePayReq")
+
+	return resp
+}
+
+// ForwardingHistory makes a RPC call to the node's ForwardingHistory and
+// asserts.
+func (h *HarnessRPC) ForwardingHistory(
+	req *lnrpc.ForwardingHistoryRequest) *lnrpc.ForwardingHistoryResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	if req == nil {
+		req = &lnrpc.ForwardingHistoryRequest{}
+	}
+
+	resp, err := h.LN.ForwardingHistory(ctxt, req)
+	h.NoError(err, "ForwardingHistory")
+
+	return resp
+}
+
+type MiddlewareClient lnrpc.Lightning_RegisterRPCMiddlewareClient
+
+// RegisterRPCMiddleware makes a RPC call to the node's RegisterRPCMiddleware
+// and asserts. It also returns a cancel context which can cancel the context
+// used by the client.
+func (h *HarnessRPC) RegisterRPCMiddleware() (MiddlewareClient,
+	context.CancelFunc) {
+
+	ctxt, cancel := context.WithCancel(h.runCtx)
+
+	stream, err := h.LN.RegisterRPCMiddleware(ctxt)
+	h.NoError(err, "RegisterRPCMiddleware")
+
+	return stream, cancel
+}
+
+type ChannelEventsClient lnrpc.Lightning_SubscribeChannelEventsClient
+
+// SubscribeChannelEvents creates a subscription client for channel events and
+// asserts its creation.
+func (h *HarnessRPC) SubscribeChannelEvents() ChannelEventsClient {
+	req := &lnrpc.ChannelEventSubscription{}
+
+	// SubscribeChannelEvents needs to have the context alive for the
+	// entire test case as the returned client will be used for send and
+	// receive events stream. Thus we use runCtx here instead of a timeout
+	// context.
+	client, err := h.LN.SubscribeChannelEvents(h.runCtx, req)
+	h.NoError(err, "SubscribeChannelEvents")
+
+	return client
+}
+
+type CustomMessageClient lnrpc.Lightning_SubscribeCustomMessagesClient
+
+// SubscribeCustomMessages creates a subscription client for custom messages.
+func (h *HarnessRPC) SubscribeCustomMessages() (CustomMessageClient,
+	context.CancelFunc) {
+
+	ctxt, cancel := context.WithCancel(h.runCtx)
+
+	req := &lnrpc.SubscribeCustomMessagesRequest{}
+
+	// SubscribeCustomMessages needs to have the context alive for the
+	// entire test case as the returned client will be used for send and
+	// receive events stream. Thus we use runCtx here instead of a timeout
+	// context.
+	stream, err := h.LN.SubscribeCustomMessages(ctxt, req)
+	h.NoError(err, "SubscribeCustomMessages")
+
+	return stream, cancel
+}
+
+// SendCustomMessage makes a RPC call to the node's SendCustomMessage and
+// returns the response.
+func (h *HarnessRPC) SendCustomMessage(
+	req *lnrpc.SendCustomMessageRequest) *lnrpc.SendCustomMessageResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.LN.SendCustomMessage(ctxt, req)
+	h.NoError(err, "SendCustomMessage")
+
+	return resp
+}

lntest/rpc/neutrino_kit.go

@@ -0,0 +1,54 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc/neutrinorpc"
+)
+
+// =====================
+// NeutrinoKitClient related RPCs.
+// =====================
+
+// Status makes an RPC call to neutrino kit client's Status and asserts.
+func (h *HarnessRPC) Status(
+	req *neutrinorpc.StatusRequest) *neutrinorpc.StatusResponse {
+
+	if req == nil {
+		req = &neutrinorpc.StatusRequest{}
+	}
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.NeutrinoKit.Status(ctxt, req)
+	h.NoError(err, "Status")
+
+	return resp
+}
+
+// GetCFilter makes an RPC call to neutrino kit client's GetCFilter and asserts.
+func (h *HarnessRPC) GetCFilter(
+	req *neutrinorpc.GetCFilterRequest) *neutrinorpc.GetCFilterResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.NeutrinoKit.GetCFilter(ctxt, req)
+	h.NoError(err, "GetCFilter")
+
+	return resp
+}
+
+// AddPeer makes an RPC call to neutrino kit client's AddPeer and asserts.
+func (h *HarnessRPC) AddPeer(
+	req *neutrinorpc.AddPeerRequest) *neutrinorpc.AddPeerResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.NeutrinoKit.AddPeer(ctxt, req)
+	h.NoError(err, "AddPeer")
+
+	return resp
+}

lntest/rpc/peers.go

@@ -0,0 +1,39 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc/peersrpc"
+	"github.com/stretchr/testify/require"
+)
+
+// =====================
+// PeerClient related RPCs.
+// =====================
+
+type (
+	AnnReq  *peersrpc.NodeAnnouncementUpdateRequest
+	AnnResp *peersrpc.NodeAnnouncementUpdateResponse
+)
+
+// UpdateNodeAnnouncement makes an UpdateNodeAnnouncement RPC call the peersrpc
+// client and asserts.
+func (h *HarnessRPC) UpdateNodeAnnouncement(req AnnReq) AnnResp {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Peer.UpdateNodeAnnouncement(ctxt, req)
+	h.NoError(err, "UpdateNodeAnnouncement")
+
+	return resp
+}
+
+// UpdateNodeAnnouncementErr makes an UpdateNodeAnnouncement RPC call the
+// peersrpc client and asserts an error is returned.
+func (h *HarnessRPC) UpdateNodeAnnouncementErr(req AnnReq) {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Peer.UpdateNodeAnnouncement(ctxt, req)
+	require.Error(h, err, "expect an error from update announcement")
+}

lntest/rpc/router.go

@@ -0,0 +1,206 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
+	"github.com/stretchr/testify/require"
+)
+
+// =====================
+// RouterClient related RPCs.
+// =====================
+
+// UpdateChanStatus makes a UpdateChanStatus RPC call to node's RouterClient
+// and asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) UpdateChanStatus(
+	req *routerrpc.UpdateChanStatusRequest) *routerrpc.UpdateChanStatusResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Router.UpdateChanStatus(ctxt, req)
+	h.NoError(err, "UpdateChanStatus")
+
+	return resp
+}
+
+type PaymentClient routerrpc.Router_SendPaymentV2Client
+
+// SendPayment sends a payment using the given node and payment request. It
+// also asserts the payment being sent successfully.
+func (h *HarnessRPC) SendPayment(
+	req *routerrpc.SendPaymentRequest) PaymentClient {
+
+	// SendPayment needs to have the context alive for the entire test case
+	// as the router relies on the context to propagate HTLCs. Thus we use
+	// runCtx here instead of a timeout context.
+	stream, err := h.Router.SendPaymentV2(h.runCtx, req)
+	h.NoError(err, "SendPaymentV2")
+
+	return stream
+}
+
+type HtlcEventsClient routerrpc.Router_SubscribeHtlcEventsClient
+
+// SubscribeHtlcEvents makes a subscription to the HTLC events and returns a
+// htlc event client.
+func (h *HarnessRPC) SubscribeHtlcEvents() HtlcEventsClient {
+	// Use runCtx here to keep the client alive for the scope of the test.
+	client, err := h.Router.SubscribeHtlcEvents(
+		h.runCtx, &routerrpc.SubscribeHtlcEventsRequest{},
+	)
+	h.NoError(err, "SubscribeHtlcEvents")
+
+	return client
+}
+
+// GetMissionControlConfig makes a RPC call to the node's
+// GetMissionControlConfig and asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) GetMissionControlConfig() *routerrpc.GetMissionControlConfigResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &routerrpc.GetMissionControlConfigRequest{}
+	resp, err := h.Router.GetMissionControlConfig(ctxt, req)
+	h.NoError(err, "GetMissionControlConfig")
+
+	return resp
+}
+
+// SetMissionControlConfig makes a RPC call to the node's
+// SetMissionControlConfig and asserts.
+func (h *HarnessRPC) SetMissionControlConfig(
+	config *routerrpc.MissionControlConfig) {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &routerrpc.SetMissionControlConfigRequest{Config: config}
+	_, err := h.Router.SetMissionControlConfig(ctxt, req)
+	h.NoError(err, "SetMissionControlConfig")
+}
+
+// SetMissionControlConfigAssertErr makes a RPC call to the node's
+// SetMissionControlConfig and asserts that we error.
+func (h *HarnessRPC) SetMissionControlConfigAssertErr(
+	config *routerrpc.MissionControlConfig) {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &routerrpc.SetMissionControlConfigRequest{Config: config}
+	_, err := h.Router.SetMissionControlConfig(ctxt, req)
+	require.Error(h, err, "expect an error from setting import mission "+
+		"control")
+}
+
+// ResetMissionControl makes a RPC call to the node's ResetMissionControl and
+// asserts.
+func (h *HarnessRPC) ResetMissionControl() {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &routerrpc.ResetMissionControlRequest{}
+	_, err := h.Router.ResetMissionControl(ctxt, req)
+	h.NoError(err, "ResetMissionControl")
+}
+
+// SendToRouteV2 makes a RPC call to SendToRouteV2 and asserts.
+func (h *HarnessRPC) SendToRouteV2(
+	req *routerrpc.SendToRouteRequest) *lnrpc.HTLCAttempt {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Router.SendToRouteV2(ctxt, req)
+	h.NoError(err, "SendToRouteV2")
+
+	return resp
+}
+
+// QueryProbability makes a RPC call to the node's QueryProbability and
+// asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) QueryProbability(
+	req *routerrpc.QueryProbabilityRequest) *routerrpc.QueryProbabilityResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Router.QueryProbability(ctxt, req)
+	h.NoError(err, "QueryProbability")
+
+	return resp
+}
+
+// XImportMissionControl makes a RPC call to the node's XImportMissionControl
+// and asserts.
+func (h *HarnessRPC) XImportMissionControl(
+	req *routerrpc.XImportMissionControlRequest) {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Router.XImportMissionControl(ctxt, req)
+	h.NoError(err, "XImportMissionControl")
+}
+
+// XImportMissionControlAssertErr makes a RPC call to the node's
+// XImportMissionControl
+// and asserts an error occurred.
+func (h *HarnessRPC) XImportMissionControlAssertErr(
+	req *routerrpc.XImportMissionControlRequest) {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Router.XImportMissionControl(ctxt, req)
+	require.Error(h, err, "expect an error from x import mission control")
+}
+
+// BuildRoute makes a RPC call to the node's RouterClient and asserts.
+func (h *HarnessRPC) BuildRoute(
+	req *routerrpc.BuildRouteRequest) *routerrpc.BuildRouteResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Router.BuildRoute(ctxt, req)
+	h.NoError(err, "BuildRoute")
+
+	return resp
+}
+
+type InterceptorClient routerrpc.Router_HtlcInterceptorClient
+
+// HtlcInterceptor makes a RPC call to the node's RouterClient and asserts.
+func (h *HarnessRPC) HtlcInterceptor() (InterceptorClient, context.CancelFunc) {
+	// HtlcInterceptor needs to have the context alive for the entire test
+	// case as the returned client will be used for send and receive events
+	// stream. Thus we use cancel context here instead of a timeout
+	// context.
+	ctxt, cancel := context.WithCancel(h.runCtx)
+	resp, err := h.Router.HtlcInterceptor(ctxt)
+	h.NoError(err, "HtlcInterceptor")
+
+	return resp, cancel
+}
+
+type TrackPaymentsClient routerrpc.Router_TrackPaymentsClient
+
+// TrackPayments makes a RPC call to the node's RouterClient and asserts.
+func (h *HarnessRPC) TrackPayments(
+	req *routerrpc.TrackPaymentsRequest) TrackPaymentsClient {
+
+	resp, err := h.Router.TrackPayments(h.runCtx, req)
+	h.NoError(err, "TrackPayments")
+
+	return resp
+}

lntest/rpc/signer.go

@@ -0,0 +1,225 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
+	"github.com/stretchr/testify/require"
+)
+
+// =====================
+// Signer related RPCs.
+// =====================
+
+// DeriveSharedKey makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) DeriveSharedKey(
+	req *signrpc.SharedKeyRequest) *signrpc.SharedKeyResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.DeriveSharedKey(ctxt, req)
+	h.NoError(err, "DeriveSharedKey")
+
+	return resp
+}
+
+// DeriveSharedKeyErr makes a RPC call to the node's SignerClient and asserts
+// there is an error.
+func (h *HarnessRPC) DeriveSharedKeyErr(req *signrpc.SharedKeyRequest) error {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.DeriveSharedKey(ctxt, req)
+	require.Error(h, err, "expected error from calling DeriveSharedKey")
+
+	return err
+}
+
+// SignOutputRaw makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) SignOutputRaw(req *signrpc.SignReq) *signrpc.SignResp {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.SignOutputRaw(ctxt, req)
+	h.NoError(err, "SignOutputRaw")
+
+	return resp
+}
+
+// SignOutputRawErr makes a RPC call to the node's SignerClient and asserts an
+// error is returned.
+func (h *HarnessRPC) SignOutputRawErr(req *signrpc.SignReq) error {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.SignOutputRaw(ctxt, req)
+	require.Error(h, err, "expect to fail to sign raw output")
+
+	return err
+}
+
+// MuSig2CreateSession makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) MuSig2CreateSession(
+	req *signrpc.MuSig2SessionRequest) *signrpc.MuSig2SessionResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2CreateSession(ctxt, req)
+	h.NoError(err, "MuSig2CreateSession")
+
+	return resp
+}
+
+// MuSig2CreateSessionErr makes an RPC call to the node's SignerClient and
+// asserts an error is returned.
+func (h *HarnessRPC) MuSig2CreateSessionErr(
+	req *signrpc.MuSig2SessionRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.MuSig2CreateSession(ctxt, req)
+	require.Error(h, err, "expected error from calling MuSig2CreateSession")
+
+	return err
+}
+
+// MuSig2CombineKeys makes a RPC call to the node's SignerClient and asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) MuSig2CombineKeys(
+	req *signrpc.MuSig2CombineKeysRequest) *signrpc.MuSig2CombineKeysResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2CombineKeys(ctxt, req)
+	h.NoError(err, "MuSig2CombineKeys")
+
+	return resp
+}
+
+// MuSig2CombineKeysErr makes an RPC call to the node's SignerClient and
+// asserts an error is returned.
+func (h *HarnessRPC) MuSig2CombineKeysErr(
+	req *signrpc.MuSig2CombineKeysRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.MuSig2CombineKeys(ctxt, req)
+	require.Error(h, err, "expected error from calling MuSig2CombineKeys")
+
+	return err
+}
+
+// MuSig2RegisterNonces makes a RPC call to the node's SignerClient and asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) MuSig2RegisterNonces(
+	req *signrpc.MuSig2RegisterNoncesRequest) *signrpc.MuSig2RegisterNoncesResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2RegisterNonces(ctxt, req)
+	h.NoError(err, "MuSig2RegisterNonces")
+
+	return resp
+}
+
+// MuSig2Sign makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) MuSig2Sign(
+	req *signrpc.MuSig2SignRequest) *signrpc.MuSig2SignResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2Sign(ctxt, req)
+	h.NoError(err, "MuSig2Sign")
+
+	return resp
+}
+
+// MuSig2SignErr makes a RPC call to the node's SignerClient and asserts an
+// error is returned.
+func (h *HarnessRPC) MuSig2SignErr(req *signrpc.MuSig2SignRequest) error {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.MuSig2Sign(ctxt, req)
+	require.Error(h, err, "expect an error")
+
+	return err
+}
+
+// MuSig2CombineSig makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) MuSig2CombineSig(
+	r *signrpc.MuSig2CombineSigRequest) *signrpc.MuSig2CombineSigResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2CombineSig(ctxt, r)
+	h.NoError(err, "MuSig2CombineSig")
+
+	return resp
+}
+
+// MuSig2Cleanup makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) MuSig2Cleanup(
+	req *signrpc.MuSig2CleanupRequest) *signrpc.MuSig2CleanupResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2Cleanup(ctxt, req)
+	h.NoError(err, "MuSig2Cleanup")
+
+	return resp
+}
+
+// SignMessageSigner makes a RPC call to the node's SignerClient and asserts.
+//
+// NOTE: there's already `SignMessage` in `h.LN`.
+func (h *HarnessRPC) SignMessageSigner(
+	req *signrpc.SignMessageReq) *signrpc.SignMessageResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.SignMessage(ctxt, req)
+	h.NoError(err, "SignMessage")
+
+	return resp
+}
+
+// VerifyMessageSigner makes a RPC call to the node's SignerClient and asserts.
+//
+// NOTE: there's already `VerifyMessageSigner` in `h.LN`.
+func (h *HarnessRPC) VerifyMessageSigner(
+	req *signrpc.VerifyMessageReq) *signrpc.VerifyMessageResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.VerifyMessage(ctxt, req)
+	h.NoError(err, "VerifyMessage")
+
+	return resp
+}
+
+// ComputeInputScript makes a RPC call to the node's SignerClient and asserts.
+func (h *HarnessRPC) ComputeInputScript(
+	req *signrpc.SignReq) *signrpc.InputScriptResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.ComputeInputScript(ctxt, req)
+	h.NoError(err, "ComputeInputScript")
+
+	return resp
+}

lntest/rpc/state.go

@@ -0,0 +1,19 @@
+package rpc
+
+import (
+	"github.com/lightningnetwork/lnd/lnrpc"
+)
+
+// =====================
+// StateClient related RPCs.
+// =====================
+
+// SubscribeState makes a rpc call to StateClient and asserts there's no error.
+func (h *HarnessRPC) SubscribeState() lnrpc.State_SubscribeStateClient {
+	client, err := h.State.SubscribeState(
+		h.runCtx, &lnrpc.SubscribeStateRequest{},
+	)
+	h.NoError(err, "SubscribeState")
+
+	return client
+}

lntest/rpc/wallet_kit.go

@@ -0,0 +1,279 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
+	"github.com/stretchr/testify/require"
+)
+
+// =====================
+// WalletKitClient related RPCs.
+// =====================
+
+type (
+	SignReq    *walletrpc.SignMessageWithAddrResponse
+	VerifyResp *walletrpc.VerifyMessageWithAddrResponse
+)
+
+// FinalizePsbt makes a RPC call to node's ListUnspent and asserts.
+func (h *HarnessRPC) ListUnspent(
+	req *walletrpc.ListUnspentRequest) *walletrpc.ListUnspentResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.ListUnspent(ctxt, req)
+	h.NoError(err, "ListUnspent")
+
+	return resp
+}
+
+// DeriveKey makes a RPC call to the DeriveKey and asserts.
+func (h *HarnessRPC) DeriveKey(kl *signrpc.KeyLocator) *signrpc.KeyDescriptor {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	key, err := h.WalletKit.DeriveKey(ctxt, kl)
+	h.NoError(err, "DeriveKey")
+
+	return key
+}
+
+// SendOutputs makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) SendOutputs(
+	req *walletrpc.SendOutputsRequest) *walletrpc.SendOutputsResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.SendOutputs(ctxt, req)
+	h.NoError(err, "SendOutputs")
+
+	return resp
+}
+
+// FundPsbt makes a RPC call to node's FundPsbt and asserts.
+func (h *HarnessRPC) FundPsbt(
+	req *walletrpc.FundPsbtRequest) *walletrpc.FundPsbtResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.FundPsbt(ctxt, req)
+	h.NoError(err, "FundPsbt")
+
+	return resp
+}
+
+// FinalizePsbt makes a RPC call to node's FinalizePsbt and asserts.
+func (h *HarnessRPC) FinalizePsbt(
+	req *walletrpc.FinalizePsbtRequest) *walletrpc.FinalizePsbtResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.FinalizePsbt(ctxt, req)
+	h.NoError(err, "FinalizePsbt")
+
+	return resp
+}
+
+// LabelTransactionAssertErr makes a RPC call to the node's LabelTransaction
+// and asserts an error is returned. It then returns the error.
+func (h *HarnessRPC) LabelTransactionAssertErr(
+	req *walletrpc.LabelTransactionRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.WalletKit.LabelTransaction(ctxt, req)
+	require.Error(h, err, "expected error returned")
+
+	return err
+}
+
+// LabelTransaction makes a RPC call to the node's LabelTransaction
+// and asserts no error is returned.
+func (h *HarnessRPC) LabelTransaction(req *walletrpc.LabelTransactionRequest) {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.WalletKit.LabelTransaction(ctxt, req)
+	h.NoError(err, "LabelTransaction")
+}
+
+// DeriveNextKey makes a RPC call to the DeriveNextKey and asserts.
+func (h *HarnessRPC) DeriveNextKey(
+	req *walletrpc.KeyReq) *signrpc.KeyDescriptor {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	key, err := h.WalletKit.DeriveNextKey(ctxt, req)
+	h.NoError(err, "DeriveNextKey")
+
+	return key
+}
+
+// ListAddresses makes a RPC call to the ListAddresses and asserts.
+func (h *HarnessRPC) ListAddresses(
+	req *walletrpc.ListAddressesRequest) *walletrpc.ListAddressesResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	key, err := h.WalletKit.ListAddresses(ctxt, req)
+	h.NoError(err, "ListAddresses")
+
+	return key
+}
+
+// SignMessageWithAddr makes a RPC call to the SignMessageWithAddr and asserts.
+func (h *HarnessRPC) SignMessageWithAddr(
+	req *walletrpc.SignMessageWithAddrRequest) SignReq {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	key, err := h.WalletKit.SignMessageWithAddr(ctxt, req)
+	h.NoError(err, "SignMessageWithAddr")
+
+	return key
+}
+
+// VerifyMessageWithAddr makes a RPC call to
+// the VerifyMessageWithAddr and asserts.
+func (h *HarnessRPC) VerifyMessageWithAddr(
+	req *walletrpc.VerifyMessageWithAddrRequest) VerifyResp {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	key, err := h.WalletKit.VerifyMessageWithAddr(ctxt, req)
+	h.NoError(err, "VerifyMessageWithAddr")
+
+	return key
+}
+
+// ListSweeps makes a ListSweeps RPC call to the node's WalletKit client.
+func (h *HarnessRPC) ListSweeps(verbose bool) *walletrpc.ListSweepsResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &walletrpc.ListSweepsRequest{Verbose: verbose}
+	resp, err := h.WalletKit.ListSweeps(ctxt, req)
+	h.NoError(err, "ListSweeps")
+
+	return resp
+}
+
+// PendingSweeps makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) PendingSweeps() *walletrpc.PendingSweepsResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &walletrpc.PendingSweepsRequest{}
+
+	resp, err := h.WalletKit.PendingSweeps(ctxt, req)
+	h.NoError(err, "PendingSweeps")
+
+	return resp
+}
+
+// PublishTransaction makes an RPC call to the node's WalletKitClient and
+// asserts.
+func (h *HarnessRPC) PublishTransaction(
+	req *walletrpc.Transaction) *walletrpc.PublishResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.PublishTransaction(ctxt, req)
+	h.NoError(err, "PublishTransaction")
+
+	return resp
+}
+
+// BumpFee makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) BumpFee(
+	req *walletrpc.BumpFeeRequest) *walletrpc.BumpFeeResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.BumpFee(ctxt, req)
+	h.NoError(err, "BumpFee")
+
+	return resp
+}
+
+// ListAccounts makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) ListAccounts(
+	req *walletrpc.ListAccountsRequest) *walletrpc.ListAccountsResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.ListAccounts(ctxt, req)
+	h.NoError(err, "ListAccounts")
+
+	return resp
+}
+
+// ImportAccount makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) ImportAccount(
+	req *walletrpc.ImportAccountRequest) *walletrpc.ImportAccountResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.ImportAccount(ctxt, req)
+	h.NoError(err, "ImportAccount")
+
+	return resp
+}
+
+// ImportPublicKey makes a RPC call to the node's WalletKitClient and asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) ImportPublicKey(
+	req *walletrpc.ImportPublicKeyRequest) *walletrpc.ImportPublicKeyResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.ImportPublicKey(ctxt, req)
+	h.NoError(err, "ImportPublicKey")
+
+	return resp
+}
+
+// SignPsbt makes a RPC call to the node's WalletKitClient and asserts.
+func (h *HarnessRPC) SignPsbt(
+	req *walletrpc.SignPsbtRequest) *walletrpc.SignPsbtResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.SignPsbt(ctxt, req)
+	h.NoError(err, "SignPsbt")
+
+	return resp
+}
+
+// ImportTapscript makes a RPC call to the node's WalletKitClient and asserts.
+//
+//nolint:lll
+func (h *HarnessRPC) ImportTapscript(
+	req *walletrpc.ImportTapscriptRequest) *walletrpc.ImportTapscriptResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletKit.ImportTapscript(ctxt, req)
+	h.NoError(err, "ImportTapscript")
+
+	return resp
+}

lntest/rpc/wallet_unlocker.go

@@ -0,0 +1,64 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc"
+)
+
+// =====================
+// WalletUnlockerClient related RPCs.
+// =====================
+
+// UnlockWallet makes a RPC request to WalletUnlocker and asserts there's no
+// error.
+func (h *HarnessRPC) UnlockWallet(
+	req *lnrpc.UnlockWalletRequest) *lnrpc.UnlockWalletResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletUnlocker.UnlockWallet(ctxt, req)
+	h.NoError(err, "UnlockWallet")
+
+	return resp
+}
+
+// InitWallet makes a RPC request to WalletUnlocker and asserts there's no
+// error.
+func (h *HarnessRPC) InitWallet(
+	req *lnrpc.InitWalletRequest) *lnrpc.InitWalletResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletUnlocker.InitWallet(ctxt, req)
+	h.NoError(err, "InitWallet")
+
+	return resp
+}
+
+// GenSeed makes a RPC request to WalletUnlocker and asserts there's no error.
+func (h *HarnessRPC) GenSeed(req *lnrpc.GenSeedRequest) *lnrpc.GenSeedResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletUnlocker.GenSeed(ctxt, req)
+	h.NoError(err, "GenSeed")
+
+	return resp
+}
+
+// ChangePassword makes a RPC request to WalletUnlocker and asserts there's no
+// error.
+func (h *HarnessRPC) ChangePassword(
+	req *lnrpc.ChangePasswordRequest) *lnrpc.ChangePasswordResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WalletUnlocker.ChangePassword(ctxt, req)
+	h.NoError(err, "ChangePassword")
+
+	return resp
+}

lntest/rpc/watchtower.go

@@ -0,0 +1,52 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/lightningnetwork/lnd/lnrpc/watchtowerrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/wtclientrpc"
+)
+
+// =====================
+// WatchtowerClient and WatchtowerClientClient related RPCs.
+// =====================
+
+// GetInfoWatchtower makes a RPC call to the watchtower of the given node and
+// asserts.
+func (h *HarnessRPC) GetInfoWatchtower() *watchtowerrpc.GetInfoResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &watchtowerrpc.GetInfoRequest{}
+	info, err := h.Watchtower.GetInfo(ctxt, req)
+	h.NoError(err, "GetInfo from Watchtower")
+
+	return info
+}
+
+// AddTower makes a RPC call to the WatchtowerClient of the given node and
+// asserts.
+func (h *HarnessRPC) AddTower(
+	req *wtclientrpc.AddTowerRequest) *wtclientrpc.AddTowerResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.WatchtowerClient.AddTower(ctxt, req)
+	h.NoError(err, "AddTower")
+
+	return resp
+}
+
+// WatchtowerStats makes a RPC call to the WatchtowerClient of the given node
+// and asserts.
+func (h *HarnessRPC) WatchtowerStats() *wtclientrpc.StatsResponse {
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	req := &wtclientrpc.StatsRequest{}
+	resp, err := h.WatchtowerClient.Stats(ctxt, req)
+	h.NoError(err, "Stats from Watchtower")
+
+	return resp
+}