package manifest import ( "errors" "sort" "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" ) const ( // MethodInit is a name for default initialization method. MethodInit = "_initialize" // MethodDeploy is a name for default method called during contract deployment. MethodDeploy = "_deploy" // MethodVerify is a name for default verification method. MethodVerify = "verify" // MethodOnNEP17Payment is the name of the method which is called when contract receives NEP-17 tokens. MethodOnNEP17Payment = "onNEP17Payment" // MethodOnNEP11Payment is the name of the method which is called when contract receives NEP-11 tokens. MethodOnNEP11Payment = "onNEP11Payment" ) // ABI represents a contract application binary interface. type ABI struct { Methods []Method `json:"methods"` Events []Event `json:"events"` } // GetMethod returns methods with the specified name. func (a *ABI) GetMethod(name string, paramCount int) *Method { for i := range a.Methods { if a.Methods[i].Name == name && (paramCount == -1 || len(a.Methods[i].Parameters) == paramCount) { return &a.Methods[i] } } return nil } // GetEvent returns the event with the specified name. func (a *ABI) GetEvent(name string) *Event { for i := range a.Events { if a.Events[i].Name == name { return &a.Events[i] } } return nil } // IsValid checks ABI consistency and correctness. func (a *ABI) IsValid() error { if len(a.Methods) == 0 { return errors.New("ABI contains no methods") } for i := range a.Methods { err := a.Methods[i].IsValid() if err != nil { return err } } if len(a.Methods) > 1 { methods := make([]struct { name string params int }, len(a.Methods)) for i := range methods { methods[i].name = a.Methods[i].Name methods[i].params = len(a.Methods[i].Parameters) } sort.Slice(methods, func(i, j int) bool { if methods[i].name < methods[j].name { return true } if methods[i].name == methods[j].name { return methods[i].params < methods[j].params } return false }) for i := range methods { if i == 0 { continue } if methods[i].name == methods[i-1].name && methods[i].params == methods[i-1].params { return errors.New("duplicate method specifications") } } } for i := range a.Events { err := a.Events[i].IsValid() if err != nil { return err } } if len(a.Events) > 1 { names := make([]string, len(a.Events)) for i := range a.Events { names[i] = a.Events[i].Name } if stringsHaveDups(names) { return errors.New("duplicate event names") } } return nil } // ToStackItem converts ABI to stackitem.Item. func (a *ABI) ToStackItem() stackitem.Item { methods := make([]stackitem.Item, len(a.Methods)) for i := range a.Methods { methods[i] = a.Methods[i].ToStackItem() } events := make([]stackitem.Item, len(a.Events)) for i := range a.Events { events[i] = a.Events[i].ToStackItem() } return stackitem.NewStruct([]stackitem.Item{ stackitem.Make(methods), stackitem.Make(events), }) } // FromStackItem converts stackitem.Item to ABI. func (a *ABI) FromStackItem(item stackitem.Item) error { if item.Type() != stackitem.StructT { return errors.New("invalid ABI stackitem type") } str := item.Value().([]stackitem.Item) if len(str) != 2 { return errors.New("invalid ABI stackitem length") } if str[0].Type() != stackitem.ArrayT { return errors.New("invalid Methods stackitem type") } methods := str[0].Value().([]stackitem.Item) a.Methods = make([]Method, len(methods)) for i := range methods { m := new(Method) if err := m.FromStackItem(methods[i]); err != nil { return err } a.Methods[i] = *m } if str[1].Type() != stackitem.ArrayT { return errors.New("invalid Events stackitem type") } events := str[1].Value().([]stackitem.Item) a.Events = make([]Event, len(events)) for i := range events { e := new(Event) if err := e.FromStackItem(events[i]); err != nil { return err } a.Events[i] = *e } return nil }