diff --git a/lntemp/rpc/signer.go b/lntemp/rpc/signer.go index c7f54e12c..58cfb6f5f 100644 --- a/lntemp/rpc/signer.go +++ b/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 +} diff --git a/lntemp/rpc/wallet_kit.go b/lntemp/rpc/wallet_kit.go index fe1ccdec1..5afca17b4 100644 --- a/lntemp/rpc/wallet_kit.go +++ b/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 +} diff --git a/lntest/itest/list_on_test.go b/lntest/itest/list_on_test.go index bd0b730cb..c667438c7 100644 --- a/lntest/itest/list_on_test.go +++ b/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, + }, } diff --git a/lntest/itest/lnd_signer_test.go b/lntest/itest/lnd_signer_test.go index 6cee27b82..fb4b75d3d 100644 --- a/lntest/itest/lnd_signer_test.go +++ b/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. diff --git a/lntest/itest/lnd_test_list_on_test.go b/lntest/itest/lnd_test_list_on_test.go index 83a4e4c92..64abcc026 100644 --- a/lntest/itest/lnd_test_list_on_test.go +++ b/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,