lntemp+itest: refactor testDeriveSharedKey

lntemp/rpc/signer.go

@@ -4,13 +4,38 @@ import (
 	"context"
 
 	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
+	"github.com/stretchr/testify/require"
 )
 
 // =====================
 // Signer related RPCs.
 // =====================
 
-// SignOutputRaw makes a RPC call to node's SignOutputRaw and asserts.
+// 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()
@@ -20,3 +45,105 @@ func (h *HarnessRPC) SignOutputRaw(req *signrpc.SignReq) *signrpc.SignResp {
 
 	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
+}
+
+// MuSig2CombineKeys makes a RPC call to the node's SignerClient and asserts.
+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
+}
+
+// MuSig2RegisterNonces makes a RPC call to the node's SignerClient and asserts.
+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(
+	req *signrpc.MuSig2CombineSigRequest) *signrpc.MuSig2CombineSigResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2CombineSig(ctxt, req)
+	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
+}

lntemp/rpc/wallet_kit.go

@@ -163,3 +163,68 @@ func (h *HarnessRPC) 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)
+	require.NoErrorf(h, err, "failed to import account")
+
+	return resp
+}
+
+// ImportPublicKey makes a RPC call to the node's WalletKitClient and asserts.
+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
+}

lntest/itest/list_on_test.go

@@ -441,4 +441,8 @@ var allTestCasesTemp = []*lntemp.TestCase{
 		Name:     "multiple channel creation and update subscription",
 		TestFunc: testBasicChannelCreationAndUpdates,
 	},
+	{
+		Name:     "derive shared key",
+		TestFunc: testDeriveSharedKey,
+	},
 }

lntest/itest/lnd_signer_test.go

@@ -15,6 +15,8 @@ import (
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
+	"github.com/lightningnetwork/lnd/lntemp"
+	"github.com/lightningnetwork/lnd/lntemp/node"
 	"github.com/lightningnetwork/lnd/lntest"
 	"github.com/stretchr/testify/require"
 )
@@ -23,21 +25,19 @@ import (
 // DeriveSharedKey. It creates an ephemeral private key, performing an ECDH with
 // the node's pubkey and a customized public key to check the validity of the
 // result.
-func testDeriveSharedKey(net *lntest.NetworkHarness, t *harnessTest) {
-	runDeriveSharedKey(t, net.Alice)
+func testDeriveSharedKey(ht *lntemp.HarnessTest) {
+	runDeriveSharedKey(ht, ht.Alice)
 }
 
 // runDeriveSharedKey checks the ECDH performed by the endpoint
 // DeriveSharedKey. It creates an ephemeral private key, performing an ECDH with
 // the node's pubkey and a customized public key to check the validity of the
 // result.
-func runDeriveSharedKey(t *harnessTest, alice *lntest.HarnessNode) {
-	ctxb := context.Background()
-
+func runDeriveSharedKey(ht *lntemp.HarnessTest, alice *node.HarnessNode) {
 	// Create an ephemeral key, extracts its public key, and make a
 	// PrivKeyECDH using the ephemeral key.
 	ephemeralPriv, err := btcec.NewPrivateKey()
-	require.NoError(t.t, err, "failed to create ephemeral key")
+	require.NoError(ht, err, "failed to create ephemeral key")
 
 	ephemeralPubBytes := ephemeralPriv.PubKey().SerializeCompressed()
 	privKeyECDH := &keychain.PrivKeyECDH{PrivKey: ephemeralPriv}
@@ -47,30 +47,27 @@ func runDeriveSharedKey(t *harnessTest, alice *lntest.HarnessNode) {
 	assertECDHMatch := func(pub *btcec.PublicKey,
 		req *signrpc.SharedKeyRequest) {
 
-		ctxt, _ := context.WithTimeout(ctxb, defaultTimeout)
-		resp, err := alice.SignerClient.DeriveSharedKey(ctxt, req)
-		require.NoError(t.t, err, "calling DeriveSharedKey failed")
+		resp := alice.RPC.DeriveSharedKey(req)
 
 		sharedKey, _ := privKeyECDH.ECDH(pub)
-		require.Equal(
-			t.t, sharedKey[:], resp.SharedKey,
-			"failed to derive the expected key",
-		)
+		require.Equal(ht, sharedKey[:], resp.SharedKey,
+			"failed to derive the expected key")
 	}
 
 	nodePub, err := btcec.ParsePubKey(alice.PubKey[:])
-	require.NoError(t.t, err, "failed to parse node pubkey")
+	require.NoError(ht, err, "failed to parse node pubkey")
 
 	customizedKeyFamily := int32(keychain.KeyFamilyMultiSig)
 	customizedIndex := int32(1)
 
-	customizedPub, err := deriveCustomizedKey(
-		ctxb, alice, &signrpc.KeyLocator{
-			KeyFamily: customizedKeyFamily,
-			KeyIndex:  customizedIndex,
-		},
-	)
-	require.NoError(t.t, err, "failed to create customized pubkey")
+	// Derive a customized key.
+	deriveReq := &signrpc.KeyLocator{
+		KeyFamily: customizedKeyFamily,
+		KeyIndex:  customizedIndex,
+	}
+	resp := alice.RPC.DeriveKey(deriveReq)
+	customizedPub, err := btcec.ParsePubKey(resp.RawKeyBytes)
+	require.NoError(ht, err, "failed to parse node pubkey")
 
 	// Test DeriveSharedKey with no optional arguments. It will result in
 	// performing an ECDH between the ephemeral key and the node's pubkey.
@@ -154,12 +151,8 @@ func runDeriveSharedKey(t *harnessTest, alice *lntest.HarnessNode) {
 	// assertErrorMatch checks when calling DeriveSharedKey with invalid
 	// params, the expected error is returned.
 	assertErrorMatch := func(match string, req *signrpc.SharedKeyRequest) {
-		ctxt, _ := context.WithTimeout(ctxb, defaultTimeout)
-		_, err := alice.SignerClient.DeriveSharedKey(ctxt, req)
-		require.Error(t.t, err, "expected to have an error")
-		require.Contains(
-			t.t, err.Error(), match, "error failed to match",
-		)
+		err := alice.RPC.DeriveSharedKeyErr(req)
+		require.Contains(ht, err.Error(), match, "error not match")
 	}
 
 	// Test that EphemeralPubkey must be supplied.

lntest/itest/lnd_test_list_on_test.go

@@ -4,10 +4,6 @@
 package itest
 
 var allTestCases = []*testCase{
-	{
-		name: "derive shared key",
-		test: testDeriveSharedKey,
-	},
 	{
 		name: "sign output raw",
 		test: testSignOutputRaw,