refactor: rename ed25519 struct types

Author: alanshaw

principal/ed25519/signer.go

@@ -24,20 +24,20 @@ const keySize = ed25519.SeedSize
 
 var size = tagSize + keySize
 
-func Generate() (Ed25519Signer, error) {
+func Generate() (Signer, error) {
 	_, priv, err := ed25519.GenerateKey(rand.Reader)
 	if err != nil {
 		return nil, fmt.Errorf("generating Ed25519 key: %w", err)
 	}
-	s := make(Ed25519Signer, size)
+	s := make(Signer, size)
 	varint.PutUvarint(s, Code)
 	copy(s[tagSize:], priv)
 	return s, nil
 }
 
 // Parse parses a multibase encoded string containing a ed25519 signer
 // multiformat varint (0x1300) + 32 byte ed25519 private key
-func Parse(str string) (Ed25519Signer, error) {
+func Parse(str string) (Signer, error) {
 	_, bytes, err := multibase.Decode(str)
 	if err != nil {
 		return nil, fmt.Errorf("decoding multibase string: %w", err)
@@ -47,7 +47,7 @@ func Parse(str string) (Ed25519Signer, error) {
 
 // Decode decodes a buffer of an ed25519 signer multiformat varint (0x1300) + 32
 // byte ed25519 private key.
-func Decode(b []byte) (Ed25519Signer, error) {
+func Decode(b []byte) (Signer, error) {
 	if len(b) != size {
 		return nil, fmt.Errorf("invalid length: %d wanted: %d", len(b), size)
 	}
@@ -60,59 +60,59 @@ func Decode(b []byte) (Ed25519Signer, error) {
 		return nil, fmt.Errorf("invalid private key codec: 0x%02x, expected: 0x%02x", skc, Code)
 	}
 
-	s := make(Ed25519Signer, size)
+	s := make(Signer, size)
 	copy(s, b)
 
 	return s, nil
 }
 
 // FromRaw takes raw 32 byte ed25519 private key bytes and tags with the ed25519
 // signer multiformat code, returning an ed25519 signer.
-func FromRaw(b []byte) (Ed25519Signer, error) {
+func FromRaw(b []byte) (Signer, error) {
 	if len(b) != ed25519.SeedSize {
 		return nil, fmt.Errorf("invalid length: %d wanted: %d", len(b), ed25519.SeedSize)
 	}
-	s := make(Ed25519Signer, size)
+	s := make(Signer, size)
 	varint.PutUvarint(s, Code)
 	copy(s[tagSize:size], b[:ed25519.SeedSize])
 	return s, nil
 }
 
-type Ed25519Signer []byte
+type Signer []byte
 
-var _ principal.Signer = (Ed25519Signer)(nil)
+var _ principal.Signer = (Signer)(nil)
 
-func (s Ed25519Signer) Code() uint64 {
+func (s Signer) Code() uint64 {
 	return Code
 }
 
-func (s Ed25519Signer) SignatureCode() uint64 {
+func (s Signer) SignatureCode() uint64 {
 	return SignatureCode
 }
 
-func (s Ed25519Signer) Verifier() principal.Verifier {
+func (s Signer) Verifier() principal.Verifier {
 	sk := ed25519.NewKeyFromSeed(s[tagSize:])
 	v, _ := verifier.FromRaw(sk.Public().(ed25519.PublicKey))
 	return v
 }
 
-func (s Ed25519Signer) DID() did.DID {
+func (s Signer) DID() did.DID {
 	return s.Verifier().DID()
 }
 
 // Bytes returns the private key bytes with multiformat prefix varint.
-func (s Ed25519Signer) Bytes() []byte {
+func (s Signer) Bytes() []byte {
 	return s
 }
 
 // Raw encodes the bytes of the private key without multiformats tags.
-func (s Ed25519Signer) Raw() []byte {
+func (s Signer) Raw() []byte {
 	pk := make([]byte, keySize)
 	copy(pk, s[tagSize:size])
 	return pk
 }
 
-func (s Ed25519Signer) Sign(msg []byte) []byte {
+func (s Signer) Sign(msg []byte) []byte {
 	sk := ed25519.NewKeyFromSeed(s[tagSize:])
 	return ed25519.Sign(sk, msg)
 }

principal/ed25519/verifier/verifier.go

@@ -23,7 +23,7 @@ const keySize = ed25519.PublicKeySize
 
 var size = publicTagSize + keySize
 
-func Parse(str string) (Ed25519Verifier, error) {
+func Parse(str string) (Verifier, error) {
 	if !strings.HasPrefix(str, did.KeyPrefix) {
 		return nil, fmt.Errorf("must start with '%s'", did.KeyPrefix)
 	}
@@ -37,7 +37,7 @@ func Parse(str string) (Ed25519Verifier, error) {
 	return Decode(bytes)
 }
 
-func Decode(b []byte) (Ed25519Verifier, error) {
+func Decode(b []byte) (Verifier, error) {
 	if len(b) != size {
 		return nil, fmt.Errorf("invalid length: %d wanted: %d", len(b), size)
 	}
@@ -48,46 +48,46 @@ func Decode(b []byte) (Ed25519Verifier, error) {
 	if code != Code {
 		return nil, fmt.Errorf("invalid public key codec: 0x%02x, expected: 0x%02x", code, Code)
 	}
-	v := make(Ed25519Verifier, size)
+	v := make(Verifier, size)
 	copy(v, b)
 	return v, nil
 }
 
 // FromRaw takes raw ed25519 public key bytes and tags with the ed25519 verifier
 // multiformat code, returning an ed25519 verifier.
-func FromRaw(b []byte) (Ed25519Verifier, error) {
+func FromRaw(b []byte) (Verifier, error) {
 	if len(b) != ed25519.PublicKeySize {
 		return nil, fmt.Errorf("invalid length: %d wanted: %d", len(b), ed25519.PublicKeySize)
 	}
-	return Ed25519Verifier(multiformat.TagWith(Code, b)), nil
+	return Verifier(multiformat.TagWith(Code, b)), nil
 }
 
-type Ed25519Verifier []byte
+type Verifier []byte
 
-var _ principal.Verifier = (Ed25519Verifier)(nil)
+var _ principal.Verifier = (Verifier)(nil)
 
-func (v Ed25519Verifier) Code() uint64 {
+func (v Verifier) Code() uint64 {
 	return Code
 }
 
-func (v Ed25519Verifier) Verify(msg []byte, sig []byte) bool {
+func (v Verifier) Verify(msg []byte, sig []byte) bool {
 	return ed25519.Verify(ed25519.PublicKey(v[publicTagSize:]), msg, sig)
 }
 
-func (v Ed25519Verifier) DID() did.DID {
+func (v Verifier) DID() did.DID {
 	b58key, _ := multibase.Encode(multibase.Base58BTC, v)
 	id, _ := did.Parse(did.KeyPrefix + b58key)
 	return id
 }
 
 // Bytes returns the public key bytes with multiformat prefix varint.
-func (v Ed25519Verifier) Bytes() []byte {
+func (v Verifier) Bytes() []byte {
 	return v
 }
 
 // Raw encodes the bytes of the public key without multiformats tags.
-func (s Ed25519Verifier) Raw() []byte {
+func (v Verifier) Raw() []byte {
 	k := make(ed25519.PublicKey, ed25519.PublicKeySize)
-	copy(k, s[publicTagSize:])
+	copy(k, v[publicTagSize:])
 	return k
 }