mirror of
https://github.com/nspcc-dev/neo-go.git
synced 2024-11-23 23:30:36 +00:00
141 lines
3.2 KiB
Go
141 lines
3.2 KiB
Go
package manifest
|
|
|
|
import (
|
|
"crypto/elliptic"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"sort"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
|
|
)
|
|
|
|
// Group represents a group of smartcontracts identified by a public key.
|
|
// Every SC in a group must provide signature of its hash to prove
|
|
// it belongs to the group.
|
|
type Group struct {
|
|
PublicKey *keys.PublicKey `json:"pubkey"`
|
|
Signature []byte `json:"signature"`
|
|
}
|
|
|
|
// Groups is just an array of Group.
|
|
type Groups []Group
|
|
|
|
type groupAux struct {
|
|
PublicKey string `json:"pubkey"`
|
|
Signature []byte `json:"signature"`
|
|
}
|
|
|
|
// IsValid checks whether the group's signature corresponds to the given hash.
|
|
func (g *Group) IsValid(h util.Uint160) error {
|
|
if !g.PublicKey.Verify(g.Signature, hash.Sha256(h.BytesBE()).BytesBE()) {
|
|
return errors.New("incorrect group signature")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AreValid checks for groups correctness and uniqueness.
|
|
func (g Groups) AreValid(h util.Uint160) error {
|
|
for i := range g {
|
|
err := g[i].IsValid(h)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if len(g) < 2 {
|
|
return nil
|
|
}
|
|
pkeys := make(keys.PublicKeys, len(g))
|
|
for i := range g {
|
|
pkeys[i] = g[i].PublicKey
|
|
}
|
|
sort.Sort(pkeys)
|
|
for i := range pkeys {
|
|
if i == 0 {
|
|
continue
|
|
}
|
|
if pkeys[i].Cmp(pkeys[i-1]) == 0 {
|
|
return errors.New("duplicate group keys")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (g Groups) Contains(k *keys.PublicKey) bool {
|
|
for i := range g {
|
|
if k.Equal(g[i].PublicKey) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// MarshalJSON implements the json.Marshaler interface.
|
|
func (g *Group) MarshalJSON() ([]byte, error) {
|
|
aux := &groupAux{
|
|
PublicKey: hex.EncodeToString(g.PublicKey.Bytes()),
|
|
Signature: g.Signature,
|
|
}
|
|
return json.Marshal(aux)
|
|
}
|
|
|
|
// UnmarshalJSON implements the json.Unmarshaler interface.
|
|
func (g *Group) UnmarshalJSON(data []byte) error {
|
|
aux := new(groupAux)
|
|
if err := json.Unmarshal(data, aux); err != nil {
|
|
return err
|
|
}
|
|
b, err := hex.DecodeString(aux.PublicKey)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pub := new(keys.PublicKey)
|
|
if err := pub.DecodeBytes(b); err != nil {
|
|
return err
|
|
}
|
|
g.PublicKey = pub
|
|
if len(aux.Signature) != keys.SignatureLen {
|
|
return errors.New("wrong signature length")
|
|
}
|
|
g.Signature = aux.Signature
|
|
return nil
|
|
}
|
|
|
|
// ToStackItem converts Group to stackitem.Item.
|
|
func (g *Group) ToStackItem() stackitem.Item {
|
|
return stackitem.NewStruct([]stackitem.Item{
|
|
stackitem.NewByteArray(g.PublicKey.Bytes()),
|
|
stackitem.NewByteArray(g.Signature),
|
|
})
|
|
}
|
|
|
|
// FromStackItem converts stackitem.Item to Group.
|
|
func (g *Group) FromStackItem(item stackitem.Item) error {
|
|
if item.Type() != stackitem.StructT {
|
|
return errors.New("invalid Group stackitem type")
|
|
}
|
|
group := item.Value().([]stackitem.Item)
|
|
if len(group) != 2 {
|
|
return errors.New("invalid Group stackitem length")
|
|
}
|
|
pKey, err := group[0].TryBytes()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
g.PublicKey, err = keys.NewPublicKeyFromBytes(pKey, elliptic.P256())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sig, err := group[1].TryBytes()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(sig) != keys.SignatureLen {
|
|
return errors.New("wrong signature length")
|
|
}
|
|
g.Signature = sig
|
|
return nil
|
|
}
|