/
vrf.go
156 lines (125 loc) · 4.09 KB
/
vrf.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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
package resolver
import (
"github.com/graph-gophers/graphql-go"
"github.com/pkg/errors"
"github.com/O1MaGnUmO1/erinaceus-vrf/core/services/keystore"
"github.com/O1MaGnUmO1/erinaceus-vrf/core/services/keystore/keys/vrfkey"
)
type VRFKeyResolver struct {
key vrfkey.KeyV2
}
func NewVRFKeyResolver(key vrfkey.KeyV2) VRFKeyResolver {
return VRFKeyResolver{key: key}
}
// ID returns the ID of the VRF key, which is the public key.
func (k VRFKeyResolver) ID() graphql.ID {
return graphql.ID(k.key.ID())
}
// Compressed returns the compressed version of the public key.
func (k VRFKeyResolver) Compressed() string {
return k.key.PublicKey.String()
}
func (k VRFKeyResolver) Uncompressed() string {
// It's highly unlikely that this call will return an error.
// If it does, we'd likely have issues all throughout the application.
// However, it's still good practice to handle the error that is returned
// rather than completely ignoring it.
uncompressed, err := k.key.PublicKey.StringUncompressed()
if err != nil {
uncompressed = "error: unable to uncompress public key"
}
return uncompressed
}
// Hash returns the hash of the VRF public key.
func (k VRFKeyResolver) Hash() string {
var hashStr string
// It's highly unlikely that this call will return an error.
// If it does, we'd likely have issues all throughout the application.
// However, it's still good practice to handle the error that is returned
// rather than completely ignoring it.
hash, err := k.key.PublicKey.Hash()
if err != nil {
hashStr = "error: unable to get public key hash"
} else {
hashStr = hash.String()
}
return hashStr
}
type VRFKeySuccessResolver struct {
key vrfkey.KeyV2
}
func NewVRFKeySuccessResolver(key vrfkey.KeyV2) *VRFKeySuccessResolver {
return &VRFKeySuccessResolver{key: key}
}
func (r *VRFKeySuccessResolver) Key() VRFKeyResolver {
return NewVRFKeyResolver(r.key)
}
type VRFKeyPayloadResolver struct {
key vrfkey.KeyV2
NotFoundErrorUnionType
}
func NewVRFKeyPayloadResolver(key vrfkey.KeyV2, err error) *VRFKeyPayloadResolver {
var e NotFoundErrorUnionType
if err != nil {
e = NotFoundErrorUnionType{err: err, message: err.Error(), isExpectedErrorFn: func(err error) bool {
return errors.Is(errors.Cause(err), keystore.ErrMissingVRFKey)
}}
}
return &VRFKeyPayloadResolver{key: key, NotFoundErrorUnionType: e}
}
func (r *VRFKeyPayloadResolver) ToVRFKeySuccess() (*VRFKeySuccessResolver, bool) {
if r.err == nil {
return NewVRFKeySuccessResolver(r.key), true
}
return nil, false
}
type VRFKeysPayloadResolver struct {
keys []vrfkey.KeyV2
}
func NewVRFKeysPayloadResolver(keys []vrfkey.KeyV2) *VRFKeysPayloadResolver {
return &VRFKeysPayloadResolver{keys: keys}
}
func (r *VRFKeysPayloadResolver) Results() []VRFKeyResolver {
var results []VRFKeyResolver
for _, k := range r.keys {
results = append(results, NewVRFKeyResolver(k))
}
return results
}
type CreateVRFKeyPayloadResolver struct {
key vrfkey.KeyV2
}
func NewCreateVRFKeyPayloadResolver(key vrfkey.KeyV2) *CreateVRFKeyPayloadResolver {
return &CreateVRFKeyPayloadResolver{key: key}
}
func (r *CreateVRFKeyPayloadResolver) Key() VRFKeyResolver {
return NewVRFKeyResolver(r.key)
}
type DeleteVRFKeySuccessResolver struct {
key vrfkey.KeyV2
}
func NewDeleteVRFKeySuccessResolver(key vrfkey.KeyV2) *DeleteVRFKeySuccessResolver {
return &DeleteVRFKeySuccessResolver{key: key}
}
func (r *DeleteVRFKeySuccessResolver) Key() VRFKeyResolver {
return NewVRFKeyResolver(r.key)
}
type DeleteVRFKeyPayloadResolver struct {
key vrfkey.KeyV2
NotFoundErrorUnionType
}
func NewDeleteVRFKeyPayloadResolver(key vrfkey.KeyV2, err error) *DeleteVRFKeyPayloadResolver {
var e NotFoundErrorUnionType
if err != nil {
e = NotFoundErrorUnionType{err: err, message: err.Error(), isExpectedErrorFn: func(err error) bool {
return errors.Is(errors.Cause(err), keystore.ErrMissingVRFKey)
}}
}
return &DeleteVRFKeyPayloadResolver{key: key, NotFoundErrorUnionType: e}
}
func (r *DeleteVRFKeyPayloadResolver) ToDeleteVRFKeySuccess() (*DeleteVRFKeySuccessResolver, bool) {
if r.err == nil {
return NewDeleteVRFKeySuccessResolver(r.key), true
}
return nil, false
}