chore(lib/keystore): LoadKeyStore more explicit

cmd/gossamer/main.go

@@ -247,23 +247,12 @@ func gossamerAction(ctx *cli.Context) error {
 	}
 
 	ks := keystore.NewGlobalKeystore()
-	// load built-in test keys if specified by `cfg.Account.Key`
-	err = keystore.LoadKeystore(cfg.Account.Key, ks.Acco)
-	if err != nil {
-		logger.Errorf("failed to load account keystore: %s", err)
-		return err
-	}
-
-	err = keystore.LoadKeystore(cfg.Account.Key, ks.Babe)
-	if err != nil {
-		logger.Errorf("failed to load BABE keystore: %s", err)
-		return err
-	}
 
-	err = keystore.LoadKeystore(cfg.Account.Key, ks.Gran)
-	if err != nil {
-		logger.Errorf("failed to load grandpa keystore: %s", err)
-		return err
+	if cfg.Account.Key != "" {
+		err = loadBuiltInTestKeys(cfg.Account.Key, *ks)
+		if err != nil {
+			return fmt.Errorf("loading built-in test keys: %s", err)
+		}
 	}
 
 	// load user keys if specified
@@ -302,6 +291,35 @@ func gossamerAction(ctx *cli.Context) error {
 	return nil
 }
 
+func loadBuiltInTestKeys(accountKey string, ks keystore.GlobalKeystore) (err error) {
+	sr25519keyRing, err := keystore.NewSr25519Keyring()
+	if err != nil {
+		return fmt.Errorf("creating sr22519 keyring: %s", err)
+	}
+
+	ed25519keyRing, err := keystore.NewEd25519Keyring()
+	if err != nil {
+		return fmt.Errorf("creating ed25519 keyring: %s", err)
+	}
+
+	err = keystore.LoadKeystore(accountKey, ks.Acco, sr25519keyRing)
+	if err != nil {
+		return fmt.Errorf("loading account keystore: %w", err)
+	}
+
+	err = keystore.LoadKeystore(accountKey, ks.Babe, sr25519keyRing)
+	if err != nil {
+		return fmt.Errorf("loading babe keystore: %w", err)
+	}
+
+	err = keystore.LoadKeystore(accountKey, ks.Gran, ed25519keyRing)
+	if err != nil {
+		return fmt.Errorf("loading grandpa keystore: %w", err)
+	}
+
+	return nil
+}
+
 // initAction is the action for the "init" subcommand, initialises the trie and
 // state databases and loads initial state from the configured genesis file
 func initAction(ctx *cli.Context) error {

dot/node_integration_test.go

@@ -259,9 +259,13 @@ func TestNewNodeIntegration(t *testing.T) {
 	require.NoError(t, err)
 
 	ks := keystore.NewGlobalKeystore()
-	err = keystore.LoadKeystore("alice", ks.Gran)
+	ed25519keyRing, err := keystore.NewEd25519Keyring()
 	require.NoError(t, err)
-	err = keystore.LoadKeystore("alice", ks.Babe)
+	err = keystore.LoadKeystore("alice", ks.Gran, ed25519keyRing)
+	require.NoError(t, err)
+	sr25519keyRing, err := keystore.NewSr25519Keyring()
+	require.NoError(t, err)
+	err = keystore.LoadKeystore("alice", ks.Babe, sr25519keyRing)
 	require.NoError(t, err)
 
 	cfg.Core.Roles = common.FullNodeRole
@@ -286,10 +290,15 @@ func TestNewNode_Authority(t *testing.T) {
 	require.NoError(t, err)
 
 	ks := keystore.NewGlobalKeystore()
-	err = keystore.LoadKeystore("alice", ks.Gran)
+	ed25519keyRing, err := keystore.NewEd25519Keyring()
+	require.NoError(t, err)
+	err = keystore.LoadKeystore("alice", ks.Gran, ed25519keyRing)
 	require.NoError(t, err)
 	require.Equal(t, 1, ks.Gran.Size())
-	err = keystore.LoadKeystore("alice", ks.Babe)
+
+	sr25519keyRing, err := keystore.NewSr25519Keyring()
+	require.NoError(t, err)
+	err = keystore.LoadKeystore("alice", ks.Babe, sr25519keyRing)
 	require.NoError(t, err)
 	require.Equal(t, 1, ks.Babe.Size())
 
@@ -317,9 +326,15 @@ func TestStartStopNode(t *testing.T) {
 	require.NoError(t, err)
 
 	ks := keystore.NewGlobalKeystore()
-	err = keystore.LoadKeystore("alice", ks.Gran)
+
+	ed25519keyRing, err := keystore.NewEd25519Keyring()
+	require.NoError(t, err)
+	err = keystore.LoadKeystore("alice", ks.Gran, ed25519keyRing)
+	require.NoError(t, err)
+
+	sr25519keyRing, err := keystore.NewSr25519Keyring()
 	require.NoError(t, err)
-	err = keystore.LoadKeystore("alice", ks.Babe)
+	err = keystore.LoadKeystore("alice", ks.Babe, sr25519keyRing)
 	require.NoError(t, err)
 
 	cfg.Core.Roles = common.FullNodeRole

dot/node_test.go

@@ -5,6 +5,7 @@ package dot
 
 import (
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -158,16 +159,28 @@ func TestNodeInitialized(t *testing.T) {
 	}
 }
 
-func initKeystore(t *testing.T, cfg *Config) (*keystore.GlobalKeystore, error) {
+func initKeystore(t *testing.T, cfg *Config) (
+	globalKeyStore *keystore.GlobalKeystore, err error) {
 	ks := keystore.NewGlobalKeystore()
+
+	sr25519KeyRing, err := keystore.NewSr25519Keyring()
+	if err != nil {
+		return nil, fmt.Errorf("creating sr25519 keyring: %w", err)
+	}
+
 	// load built-in test keys if specified by `cfg.Account.Key`
-	err := keystore.LoadKeystore(cfg.Account.Key, ks.Acco)
+	err = keystore.LoadKeystore(cfg.Account.Key, ks.Acco, sr25519KeyRing)
 	require.NoError(t, err)
 
-	err = keystore.LoadKeystore(cfg.Account.Key, ks.Babe)
+	err = keystore.LoadKeystore(cfg.Account.Key, ks.Babe, sr25519KeyRing)
 	require.NoError(t, err)
 
-	err = keystore.LoadKeystore(cfg.Account.Key, ks.Gran)
+	ed25519KeyRing, err := keystore.NewEd25519Keyring()
+	if err != nil {
+		return nil, fmt.Errorf("creating ed25519 keyring: %w", err)
+	}
+
+	err = keystore.LoadKeystore(cfg.Account.Key, ks.Gran, ed25519KeyRing)
 	require.NoError(t, err)
 
 	// if authority node, should have at least 1 key in keystore

lib/keystore/helpers.go

@@ -111,62 +111,46 @@ func GenerateKeypair(keytype string, kp PublicPrivater, basepath string, passwor
 	return fp, nil
 }
 
-// LoadKeystore loads a new keystore and inserts the test key into the keystore
-func LoadKeystore(key string, ks TyperInserter) (err error) {
-	if key != "" {
-		var kr interface {
-			Alice() KeyPair
-			Bob() KeyPair
-			Charlie() KeyPair
-			Dave() KeyPair
-			Eve() KeyPair
-			Ferdie() KeyPair
-			George() KeyPair
-			Heather() KeyPair
-			Ian() KeyPair
-		}
-
-		switch ks.Type() {
-		case crypto.Ed25519Type:
-			kr, err = NewEd25519Keyring()
-			if err != nil {
-				return fmt.Errorf("failed to create keyring: %s", err)
-			}
-		default:
-			kr, err = NewSr25519Keyring()
-			if err != nil {
-				return fmt.Errorf("failed to create keyring: %s", err)
-			}
-		}
+// KeyRing is the key ring with multiple named keypairs.
+type KeyRing interface {
+	Alice() KeyPair
+	Bob() KeyPair
+	Charlie() KeyPair
+	Dave() KeyPair
+	Eve() KeyPair
+	Ferdie() KeyPair
+	George() KeyPair
+	Heather() KeyPair
+	Ian() KeyPair
+}
 
-		switch strings.ToLower(key) {
-		// Insert can error only if kestore type do not match with key
-		// type do not match. Since we have created keyring based on ks.Type(),
-		// Insert would never error here. Thus, ignoring those errors.
-		case "alice":
-			_ = ks.Insert(kr.Alice())
-		case "bob":
-			_ = ks.Insert(kr.Bob())
-		case "charlie":
-			_ = ks.Insert(kr.Charlie())
-		case "dave":
-			_ = ks.Insert(kr.Dave())
-		case "eve":
-			_ = ks.Insert(kr.Eve())
-		case "ferdie":
-			_ = ks.Insert(kr.Ferdie())
-		case "george":
-			_ = ks.Insert(kr.George())
-		case "heather":
-			_ = ks.Insert(kr.Heather())
-		case "ian":
-			_ = ks.Insert(kr.Ian())
-		default:
-			return fmt.Errorf("invalid test key provided")
-		}
+// LoadKeystore loads a new keystore and inserts the test key into the keystore
+func LoadKeystore(key string, keyStore TyperInserter, keyRing KeyRing) (err error) {
+	switch strings.ToLower(key) {
+	// Insert can error only if kestore type do not match with key
+	// type do not match. Since we have created keyring based on ks.Type(),
+	// Insert would never error here. Thus, ignoring those errors.
+	case "alice":
+		return keyStore.Insert(keyRing.Alice())
+	case "bob":
+		return keyStore.Insert(keyRing.Bob())
+	case "charlie":
+		return keyStore.Insert(keyRing.Charlie())
+	case "dave":
+		return keyStore.Insert(keyRing.Dave())
+	case "eve":
+		return keyStore.Insert(keyRing.Eve())
+	case "ferdie":
+		return keyStore.Insert(keyRing.Ferdie())
+	case "george":
+		return keyStore.Insert(keyRing.George())
+	case "heather":
+		return keyStore.Insert(keyRing.Heather())
+	case "ian":
+		return keyStore.Insert(keyRing.Ian())
+	default:
+		return fmt.Errorf("invalid test key provided")
 	}
-
-	return nil
 }
 
 // ImportKeypair imports a key specified by its filename into a subdirectory

lib/keystore/helpers_test.go

@@ -23,12 +23,19 @@ import (
 
 func TestLoadKeystore(t *testing.T) {
 	ks := NewBasicKeystore("test", crypto.Sr25519Type)
-	err := LoadKeystore("alice", ks)
+
+	sr25519KeyRing, err := NewSr25519Keyring()
+	require.NoError(t, err)
+
+	err = LoadKeystore("alice", ks, sr25519KeyRing)
 	require.NoError(t, err)
 	require.Equal(t, 1, ks.Size())
 
+	ed25519KeyRing, err := NewEd25519Keyring()
+	require.NoError(t, err)
+
 	ks = NewBasicKeystore("test", crypto.Ed25519Type)
-	err = LoadKeystore("bob", ks)
+	err = LoadKeystore("bob", ks, ed25519KeyRing)
 	require.NoError(t, err)
 	require.Equal(t, 1, ks.Size())
 }