forked from TrueCloudLab/neoneo-go
2245fedbb1
commit methods duplicated putSmthIntoStore functions, but have MemCachedStore now that can easily substitute for a Batch, especially given that interop needs something like that for its storage purposes anyway.
116 lines
3.4 KiB
Go
116 lines
3.4 KiB
Go
package core
|
|
|
|
import (
|
|
"github.com/CityOfZion/neo-go/pkg/core/storage"
|
|
"github.com/CityOfZion/neo-go/pkg/crypto/hash"
|
|
"github.com/CityOfZion/neo-go/pkg/io"
|
|
"github.com/CityOfZion/neo-go/pkg/smartcontract"
|
|
"github.com/CityOfZion/neo-go/pkg/util"
|
|
)
|
|
|
|
// Contracts is a mapping between scripthash and ContractState.
|
|
type Contracts map[util.Uint160]*ContractState
|
|
|
|
// ContractState holds information about a smart contract in the NEO blockchain.
|
|
type ContractState struct {
|
|
Script []byte
|
|
ParamList []smartcontract.ParamType
|
|
ReturnType smartcontract.ParamType
|
|
Properties smartcontract.PropertyState
|
|
Name string
|
|
CodeVersion string
|
|
Author string
|
|
Email string
|
|
Description string
|
|
|
|
scriptHash util.Uint160
|
|
}
|
|
|
|
// commit flushes all contracts to the given storage.Batch.
|
|
func (a Contracts) commit(store storage.Store) error {
|
|
for _, contract := range a {
|
|
if err := putContractStateIntoStore(store, contract); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DecodeBinary implements Serializable interface.
|
|
func (cs *ContractState) DecodeBinary(br *io.BinReader) {
|
|
cs.Script = br.ReadBytes()
|
|
paramBytes := br.ReadBytes()
|
|
cs.ParamList = make([]smartcontract.ParamType, len(paramBytes))
|
|
for k := range paramBytes {
|
|
cs.ParamList[k] = smartcontract.ParamType(paramBytes[k])
|
|
}
|
|
br.ReadLE(&cs.ReturnType)
|
|
br.ReadLE(&cs.Properties)
|
|
cs.Name = br.ReadString()
|
|
cs.CodeVersion = br.ReadString()
|
|
cs.Author = br.ReadString()
|
|
cs.Email = br.ReadString()
|
|
cs.Description = br.ReadString()
|
|
cs.createHash()
|
|
}
|
|
|
|
// EncodeBinary implements Serializable interface.
|
|
func (cs *ContractState) EncodeBinary(bw *io.BinWriter) {
|
|
bw.WriteBytes(cs.Script)
|
|
bw.WriteVarUint(uint64(len(cs.ParamList)))
|
|
for k := range cs.ParamList {
|
|
bw.WriteLE(cs.ParamList[k])
|
|
}
|
|
bw.WriteLE(cs.ReturnType)
|
|
bw.WriteLE(cs.Properties)
|
|
bw.WriteString(cs.Name)
|
|
bw.WriteString(cs.CodeVersion)
|
|
bw.WriteString(cs.Author)
|
|
bw.WriteString(cs.Email)
|
|
bw.WriteString(cs.Description)
|
|
}
|
|
|
|
// putContractStateIntoStore puts given contract state into the given store.
|
|
func putContractStateIntoStore(s storage.Store, cs *ContractState) error {
|
|
buf := io.NewBufBinWriter()
|
|
cs.EncodeBinary(buf.BinWriter)
|
|
if buf.Err != nil {
|
|
return buf.Err
|
|
}
|
|
key := storage.AppendPrefix(storage.STContract, cs.ScriptHash().Bytes())
|
|
return s.Put(key, buf.Bytes())
|
|
}
|
|
|
|
// deleteContractStateInStore deletes given contract state in the given store.
|
|
func deleteContractStateInStore(s storage.Store, hash util.Uint160) error {
|
|
key := storage.AppendPrefix(storage.STContract, hash.Bytes())
|
|
return s.Delete(key)
|
|
}
|
|
|
|
// ScriptHash returns a contract script hash.
|
|
func (cs *ContractState) ScriptHash() util.Uint160 {
|
|
if cs.scriptHash.Equals(util.Uint160{}) {
|
|
cs.createHash()
|
|
}
|
|
return cs.scriptHash
|
|
}
|
|
|
|
// createHash creates contract script hash.
|
|
func (cs *ContractState) createHash() {
|
|
cs.scriptHash = hash.Hash160(cs.Script)
|
|
}
|
|
|
|
// HasStorage checks whether the contract has storage property set.
|
|
func (cs *ContractState) HasStorage() bool {
|
|
return (cs.Properties & smartcontract.HasStorage) != 0
|
|
}
|
|
|
|
// HasDynamicInvoke checks whether the contract has dynamic invoke property set.
|
|
func (cs *ContractState) HasDynamicInvoke() bool {
|
|
return (cs.Properties & smartcontract.HasDynamicInvoke) != 0
|
|
}
|
|
|
|
// IsPayable checks whether the contract has payable property set.
|
|
func (cs *ContractState) IsPayable() bool {
|
|
return (cs.Properties & smartcontract.IsPayable) != 0
|
|
}
|