Restructure a bit

Author: connorwstein

pkg/keystore/README.md keystore/README.mdpkg/keystore/README.md renamed to keystore/README.md

@@ -1,9 +1,14 @@
 # Keystore
 Design principles:
+- Use structs for typed extensibility of the interfaces. Easy
+to wrap via a network layer if needed.
 - Storage abstract. Keystore interfaces can be implemented with memory, file, database, etc. for storage to be useable in a variety of 
 contexts. Use write through caching to maintain synchronization between in memory keys and stored keys.
 - Only the Admin interface mutates the keystore, all other interfaces
 are read only. 
 - Client side key naming. Keystore itself doesn't impose certain key algorithims/curves be used for specific contexts, it just supports a the minimum viable set of algorithms/curves for chainlink wide use cases. Clients define a name for each key which represents
 the context in which they wish to use it. 
-- Common serialization/encryption for all storage types. Protobuf serialization (compact, versioned) for key material and then key material encrypted before persistence with a passphase.
+- Common serialization/encryption for all storage types. Protobuf serialization (compact, versioned) for key material and then key material encrypted before persistence with a passphase.
+
+Notes
+- keystore/internal is copied from https://github.com/smartcontractkit/chainlink/blob/develop/core/services/keystore/internal/raw.go#L3. Intention is to switch to core to use this library at which point we can remove the core copy.

pkg/keystore/admin.go keystore/admin.gopkg/keystore/admin.go renamed to keystore/admin.go

@@ -116,10 +116,10 @@ func (ks *keystore) CreateKeys(ctx context.Context, req CreateKeysRequest) (Crea
 				createdAt:  time.Now(),
 				metadata:   []byte{},
 			}
-		case Secp256k1:
+		case EcdsaSecp256k1:
 			privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
 			if err != nil {
-				return CreateKeysResponse{}, fmt.Errorf("failed to generate Secp256k1 key: %w", err)
+				return CreateKeysResponse{}, fmt.Errorf("failed to generate EcdsaSecp256k1 key: %w", err)
 			}
 			ksCopy[keyReq.Name] = key{
 				keyType:    keyReq.KeyType,

pkg/keystore/keystore_test.go keystore/admin_reader_test.gopkg/keystore/keystore_test.go renamed to keystore/admin_reader_test.go

@@ -1,63 +1,64 @@
-package keystore
+package keystore_test
 
 import (
 	"context"
 	"testing"
 
+	"github.com/smartcontractkit/chainlink-common/pkg/keystore"
 	"github.com/smartcontractkit/chainlink-common/pkg/keystore/storage"
 	"github.com/stretchr/testify/require"
 )
 
-func TestKeystore(t *testing.T) {
+func TestKeystore_AdminReader(t *testing.T) {
 	storage := storage.NewMemoryStorage()
-	ks, err := NewKeystore(storage, "test-password")
+	ks, err := keystore.NewKeystore(storage, "test-password")
 	require.NoError(t, err)
 	ctx := context.Background()
 
-	req := CreateKeysRequest{
-		Keys: []CreateKeyRequest{
-			{Name: "test-ed25519", KeyType: Ed25519},
-			{Name: "test-secp256k1", KeyType: Secp256k1},
-			{Name: "test-x25519", KeyType: X25519},
+	req := keystore.CreateKeysRequest{
+		Keys: []keystore.CreateKeyRequest{
+			{Name: "test-ed25519", KeyType: keystore.Ed25519},
+			{Name: "test-secp256k1", KeyType: keystore.EcdsaSecp256k1},
+			{Name: "test-x25519", KeyType: keystore.X25519},
 		},
 	}
 
 	resp, err := ks.CreateKeys(ctx, req)
 	require.NoError(t, err)
 	require.Len(t, resp.Keys, 3)
 
-	expectedTypes := []KeyType{Ed25519, Secp256k1, X25519}
+	expectedTypes := []keystore.KeyType{keystore.Ed25519, keystore.EcdsaSecp256k1, keystore.X25519}
 	for i, key := range resp.Keys {
 		require.Equal(t, expectedTypes[i], key.KeyInfo.KeyType)
 		require.Equal(t, req.Keys[i].Name, key.KeyInfo.Name)
 		require.NotEmpty(t, key.KeyInfo.PublicKey, "Expected non-empty public key for %s", key.KeyInfo.Name)
 	}
 
-	getReq := GetKeysRequest{
+	getReq := keystore.GetKeysRequest{
 		Names: []string{"test-ed25519", "test-secp256k1"},
 	}
 
 	getResp, err := ks.GetKeys(ctx, getReq)
 	require.NoError(t, err)
 	require.Len(t, getResp.Keys, 2)
 
-	allKeysReq := GetKeysRequest{}
+	allKeysReq := keystore.GetKeysRequest{}
 	allKeysResp, err := ks.GetKeys(ctx, allKeysReq)
 	require.NoError(t, err)
 	require.Len(t, allKeysResp.Keys, 3)
 
-	deleteReq := DeleteKeysRequest{
+	deleteReq := keystore.DeleteKeysRequest{
 		Names: []string{"test-x25519"},
 	}
 
 	_, err = ks.DeleteKeys(ctx, deleteReq)
 	require.NoError(t, err)
 
-	deleteVerifyReq := GetKeysRequest{Names: []string{"test-x25519"}}
+	deleteVerifyReq := keystore.GetKeysRequest{Names: []string{"test-x25519"}}
 	_, err = ks.GetKeys(ctx, deleteVerifyReq)
 	require.Error(t, err)
 
-	finalKeysReq := GetKeysRequest{}
+	finalKeysReq := keystore.GetKeysRequest{}
 	finalKeysResp, err := ks.GetKeys(ctx, finalKeysReq)
 	require.NoError(t, err)
 	require.Len(t, finalKeysResp.Keys, 2)

pkg/keystore/encryptor.go keystore/encryptor.gopkg/keystore/encryptor.go renamed to keystore/encryptor.go

@@ -6,7 +6,7 @@ import (
 
 const (
 	X25519 KeyType = "X25519"
-	// TODO: Support P256
+	// TODO: Support P256 for DKG.
 )
 
 type EncryptRequest struct {
@@ -41,3 +41,5 @@ type Encryptor interface {
 	Decrypt(ctx context.Context, req DecryptRequest) (DecryptResponse, error)
 	DeriveSharedSecret(ctx context.Context, req DeriveSharedSecretRequest) (DeriveSharedSecretResponse, error)
 }
+
+// TODO: Encryptor implementation.

pkg/keystore/go.mod keystore/go.modpkg/keystore/go.mod renamed to keystore/go.mod

@@ -48,7 +48,7 @@ func (k key) publicKey() []byte {
 	switch k.keyType {
 	case Ed25519:
 		return ed25519.PublicKey(internal.Bytes(k.privateKey))
-	case Secp256k1:
+	case EcdsaSecp256k1:
 		privateKey, err := ecdsaPrivateKeyFromBytes(k.privateKey)
 		if err != nil {
 			panic(err)