/
interface.go
103 lines (91 loc) · 2.04 KB
/
interface.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package keypair
import (
"github.com/pkg/errors"
"github.com/yu-org/yu/common"
. "github.com/yu-org/yu/common/yerror"
)
const (
SecretFree = "secret-free"
Sr25519 = "sr25519"
Ed25519 = "ed25519"
Secp256k1 = "secp256k1"
SecretFreeIdx = "0"
Sr25519Idx = "1"
Ed25519Idx = "2"
Secp256k1Idx = "3"
)
var KeyTypeBytLen = 1
func GenKeyPairWithSecret(keyType string, secret []byte) (PubKey, PrivKey, error) {
switch keyType {
case SecretFree:
return nil, nil, nil
case Sr25519:
pub, priv := GenSrKeyWithSecret(secret)
return pub, priv, nil
case Ed25519:
pub, priv := GenEdKeyWithSecret(secret)
return pub, priv, nil
case Secp256k1:
pub, priv := GenSecpKeyWithSecret(secret)
return pub, priv, nil
default:
return nil, nil, NoKeyType
}
}
func GenKeyPair(keyType string) (PubKey, PrivKey, error) {
switch keyType {
case SecretFree:
return nil, nil, nil
case Sr25519:
pub, priv := GenSrKey()
return pub, priv, nil
case Ed25519:
pub, priv := GenEdKey()
return pub, priv, nil
case Secp256k1:
pub, priv := GenSecpKey()
return pub, priv, nil
default:
return nil, nil, NoKeyType
}
}
// data: (keyTypeBytes + keyBytes)
func PubKeyFromBytes(data []byte) (PubKey, error) {
if len(data) < KeyTypeBytLen {
return nil, errors.New("null data")
}
keyTypeByt := data[:KeyTypeBytLen]
switch string(keyTypeByt) {
case SecretFreeIdx:
return nil, nil
case Sr25519Idx:
return SrPubKeyFromBytes(data[KeyTypeBytLen:]), nil
case Ed25519Idx:
return EdPubKeyFromBytes(data[KeyTypeBytLen:]), nil
case Secp256k1Idx:
return SecpPubkeyFromBytes(data[KeyTypeBytLen:]), nil
default:
return nil, NoKeyType
}
}
func PubkeyFromStr(data string) (PubKey, error) {
byt := common.FromHex(data)
return PubKeyFromBytes(byt)
}
type Key interface {
Type() string
Equals(key Key) bool
Bytes() []byte
String() string
BytesWithType() []byte
StringWithType() string
}
type PubKey interface {
Key
Address() common.Address
VerifySignature(msg, sig []byte) bool
}
type PrivKey interface {
Key
SignData([]byte) ([]byte, error)
}