func FromRawSeed(prefix PrefixByte, rawSeed []byte) (KeyPair, error) {
	seed, err := EncodeSeed(prefix, rawSeed)
	if err != nil {
		return nil, err
	}
	return &kp{seed}, nil
}
FromRawSeed will create a KeyPair from the raw 32 byte seed for a given type.
package nkeys
import (
	"errors"
)
const Version = "0.1.3"
var (
	ErrInvalidPrefixByte = errors.New("nkeys: invalid prefix byte")
	ErrInvalidKey        = errors.New("nkeys: invalid key")
	ErrInvalidPublicKey  = errors.New("nkeys: invalid public key")
	ErrInvalidSeedLen    = errors.New("nkeys: invalid seed length")
	ErrInvalidSeed       = errors.New("nkeys: invalid seed")
	ErrInvalidEncoding   = errors.New("nkeys: invalid encoded key")
	ErrInvalidSignature  = errors.New("nkeys: signature verification failed")
	ErrCannotSign        = errors.New("nkeys: can not sign, no private key available")
	ErrPublicKeyOnly     = errors.New("nkeys: no seed or private key available")
	ErrIncompatibleKey   = errors.New("nkeys: incompatible key")
)
type KeyPair interface {
	Seed() ([]byte, error)
	PublicKey() (string, error)
	PrivateKey() ([]byte, error)
	Sign(input []byte) ([]byte, error)
	Verify(input []byte, sig []byte) error
	Wipe()
}
func CreateUser() (KeyPair, error) {
	return CreatePair(PrefixByteUser)
}
func CreateAccount() (KeyPair, error) {
	return CreatePair(PrefixByteAccount)
}
func CreateServer() (KeyPair, error) {
	return CreatePair(PrefixByteServer)
}
func CreateCluster() (KeyPair, error) {
	return CreatePair(PrefixByteCluster)
}
func CreateOperator() (KeyPair, error) {
	return CreatePair(PrefixByteOperator)
}
func FromPublicKey(public string) (KeyPair, error) {
	raw, err := decode([]byte(public))
	if err != nil {
		return nil, err
	}
	pre := PrefixByte(raw[0])
	if err := checkValidPublicPrefixByte(pre); err != nil {
		return nil, ErrInvalidPublicKey
	}
	return &pub{pre, raw[1:]}, nil
}
func FromSeed(seed []byte) (KeyPair, error) {
	_, _, err := DecodeSeed(seed)
	if err != nil {
		return nil, err
	}
	copy := append([]byte{}, seed...)
	return &kp{copy}, nil
}