package native import ( "encoding/json" "errors" "fmt" "math" "math/big" "github.com/nspcc-dev/neo-go/pkg/core/dao" "github.com/nspcc-dev/neo-go/pkg/core/interop" "github.com/nspcc-dev/neo-go/pkg/core/interop/contract" "github.com/nspcc-dev/neo-go/pkg/core/native/nativenames" "github.com/nspcc-dev/neo-go/pkg/core/state" "github.com/nspcc-dev/neo-go/pkg/encoding/bigint" "github.com/nspcc-dev/neo-go/pkg/smartcontract" "github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest" "github.com/nspcc-dev/neo-go/pkg/smartcontract/nef" "github.com/nspcc-dev/neo-go/pkg/util" "github.com/nspcc-dev/neo-go/pkg/vm" "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" ) // Management is contract-managing native contract. type Management struct { interop.ContractMD } // StoragePrice is the price to pay for 1 byte of storage. const StoragePrice = 100000 const ( prefixContract = 8 ) var errGasLimitExceeded = errors.New("gas limit exceeded") var keyNextAvailableID = []byte{15} // makeContractKey creates a key from account script hash. func makeContractKey(h util.Uint160) []byte { return makeUint160Key(prefixContract, h) } // newManagement creates new Management native contract. func newManagement() *Management { var m = &Management{ContractMD: *interop.NewContractMD(nativenames.Management)} desc := newDescriptor("getContract", smartcontract.ArrayType, manifest.NewParameter("hash", smartcontract.Hash160Type)) md := newMethodAndPrice(m.getContract, 1000000, smartcontract.ReadStates) m.AddMethod(md, desc) desc = newDescriptor("deploy", smartcontract.ArrayType, manifest.NewParameter("script", smartcontract.ByteArrayType), manifest.NewParameter("manifest", smartcontract.ByteArrayType)) md = newMethodAndPrice(m.deploy, 0, smartcontract.WriteStates) m.AddMethod(md, desc) desc = newDescriptor("update", smartcontract.VoidType, manifest.NewParameter("script", smartcontract.ByteArrayType), manifest.NewParameter("manifest", smartcontract.ByteArrayType)) md = newMethodAndPrice(m.update, 0, smartcontract.WriteStates) m.AddMethod(md, desc) desc = newDescriptor("destroy", smartcontract.VoidType) md = newMethodAndPrice(m.destroy, 10000000, smartcontract.WriteStates) m.AddMethod(md, desc) return m } // getContract is an implementation of public getContract method, it's run under // VM protections, so it's OK for it to panic instead of returning errors. func (m *Management) getContract(ic *interop.Context, args []stackitem.Item) stackitem.Item { hashBytes, err := args[0].TryBytes() if err != nil { panic(err) } hash, err := util.Uint160DecodeBytesBE(hashBytes) if err != nil { panic(err) } ctr, err := m.GetContract(ic.DAO, hash) if err != nil { panic(err) } return contractToStack(ctr) } // GetContract returns contract with given hash from given DAO. func (m *Management) GetContract(d dao.DAO, hash util.Uint160) (*state.Contract, error) { contract := new(state.Contract) key := makeContractKey(hash) err := getSerializableFromDAO(m.ContractID, d, key, contract) if err != nil { return nil, err } return contract, nil } func getLimitedSlice(arg stackitem.Item, max int) ([]byte, error) { _, isNull := arg.(stackitem.Null) if isNull { return nil, nil } b, err := arg.TryBytes() if err != nil { return nil, err } l := len(b) if l == 0 { return nil, errors.New("empty") } else if l > max { return nil, fmt.Errorf("len is %d (max %d)", l, max) } return b, nil } // getNefAndManifestFromItems converts input arguments into NEF and manifest // adding appropriate deployment GAS price and sanitizing inputs. func getNefAndManifestFromItems(ic *interop.Context, args []stackitem.Item) (*nef.File, *manifest.Manifest, error) { nefBytes, err := getLimitedSlice(args[0], math.MaxInt32) // Upper limits are checked during NEF deserialization. if err != nil { return nil, nil, fmt.Errorf("invalid NEF file: %w", err) } manifestBytes, err := getLimitedSlice(args[1], manifest.MaxManifestSize) if err != nil { return nil, nil, fmt.Errorf("invalid manifest: %w", err) } if !ic.VM.AddGas(ic.Chain.GetPolicer().GetStoragePrice() * int64(len(nefBytes)+len(manifestBytes))) { return nil, nil, errGasLimitExceeded } var resManifest *manifest.Manifest var resNef *nef.File if nefBytes != nil { nf, err := nef.FileFromBytes(nefBytes) if err != nil { return nil, nil, fmt.Errorf("invalid NEF file: %w", err) } resNef = &nf } if manifestBytes != nil { resManifest = new(manifest.Manifest) err := json.Unmarshal(manifestBytes, resManifest) if err != nil { return nil, nil, fmt.Errorf("invalid manifest: %w", err) } } return resNef, resManifest, nil } // deploy is an implementation of public deploy method, it's run under // VM protections, so it's OK for it to panic instead of returning errors. func (m *Management) deploy(ic *interop.Context, args []stackitem.Item) stackitem.Item { neff, manif, err := getNefAndManifestFromItems(ic, args) if err != nil { panic(err) } if neff == nil { panic(errors.New("no valid NEF provided")) } if manif == nil { panic(errors.New("no valid manifest provided")) } if ic.Tx == nil { panic(errors.New("no transaction provided")) } newcontract, err := m.Deploy(ic.DAO, ic.Tx.Sender(), neff, manif) if err != nil { panic(err) } callDeploy(ic, newcontract, false) return contractToStack(newcontract) } // Deploy creates contract's hash/ID and saves new contract into the given DAO. // It doesn't run _deploy method. func (m *Management) Deploy(d dao.DAO, sender util.Uint160, neff *nef.File, manif *manifest.Manifest) (*state.Contract, error) { h := state.CreateContractHash(sender, neff.Script) key := makeContractKey(h) si := d.GetStorageItem(m.ContractID, key) if si != nil { return nil, errors.New("contract already exists") } id, err := m.getNextContractID(d) if err != nil { return nil, err } if !manif.IsValid(h) { return nil, errors.New("invalid manifest for this contract") } newcontract := &state.Contract{ ID: id, Hash: h, Script: neff.Script, Manifest: *manif, } err = m.PutContractState(d, newcontract) if err != nil { return nil, err } return newcontract, nil } // update is an implementation of public update method, it's run under // VM protections, so it's OK for it to panic instead of returning errors. func (m *Management) update(ic *interop.Context, args []stackitem.Item) stackitem.Item { neff, manif, err := getNefAndManifestFromItems(ic, args) if err != nil { panic(err) } if neff == nil && manif == nil { panic(errors.New("both NEF and manifest are nil")) } contract, err := m.Update(ic.DAO, ic.VM.GetCallingScriptHash(), neff, manif) if err != nil { panic(err) } callDeploy(ic, contract, true) return stackitem.Null{} } // Update updates contract's script and/or manifest in the given DAO. // It doesn't run _deploy method. func (m *Management) Update(d dao.DAO, hash util.Uint160, neff *nef.File, manif *manifest.Manifest) (*state.Contract, error) { contract, err := m.GetContract(d, hash) if err != nil { return nil, errors.New("contract doesn't exist") } // if NEF was provided, update the contract script if neff != nil { contract.Script = neff.Script } // if manifest was provided, update the contract manifest if manif != nil { contract.Manifest = *manif if !contract.Manifest.IsValid(contract.Hash) { return nil, errors.New("invalid manifest for this contract") } } contract.UpdateCounter++ err = m.PutContractState(d, contract) if err != nil { return nil, err } return contract, nil } // destroy is an implementation of destroy update method, it's run under // VM protections, so it's OK for it to panic instead of returning errors. func (m *Management) destroy(ic *interop.Context, sis []stackitem.Item) stackitem.Item { hash := ic.VM.GetCallingScriptHash() err := m.Destroy(ic.DAO, hash) if err != nil { panic(err) } return stackitem.Null{} } // Destroy drops given contract from DAO along with its storage. func (m *Management) Destroy(d dao.DAO, hash util.Uint160) error { contract, err := m.GetContract(d, hash) if err != nil { return err } key := makeContractKey(hash) err = d.DeleteStorageItem(m.ContractID, key) if err != nil { return err } err = d.DeleteContractID(contract.ID) if err != nil { return err } siMap, err := d.GetStorageItems(contract.ID) if err != nil { return err } for k := range siMap { err := d.DeleteStorageItem(contract.ID, []byte(k)) if err != nil { return err } } return nil } func callDeploy(ic *interop.Context, cs *state.Contract, isUpdate bool) { md := cs.Manifest.ABI.GetMethod(manifest.MethodDeploy) if md != nil { err := contract.CallExInternal(ic, cs, manifest.MethodDeploy, []stackitem.Item{stackitem.NewBool(isUpdate)}, smartcontract.All, vm.EnsureIsEmpty) if err != nil { panic(err) } } } func contractToStack(cs *state.Contract) stackitem.Item { si, err := cs.ToStackItem() if err != nil { panic(fmt.Errorf("contract to stack item: %w", err)) } return si } // Metadata implements Contract interface. func (m *Management) Metadata() *interop.ContractMD { return &m.ContractMD } // OnPersist implements Contract interface. func (m *Management) OnPersist(ic *interop.Context) error { if ic.Block.Index != 0 { // We're only deploying at 0 at the moment. return nil } for _, native := range ic.Natives { md := native.Metadata() cs := &state.Contract{ ID: md.ContractID, Hash: md.Hash, Script: md.Script, Manifest: md.Manifest, } err := m.PutContractState(ic.DAO, cs) if err != nil { return err } if err := native.Initialize(ic); err != nil { return fmt.Errorf("initializing %s native contract: %w", md.Name, err) } } return nil } // PostPersist implements Contract interface. func (m *Management) PostPersist(_ *interop.Context) error { return nil } // Initialize implements Contract interface. func (m *Management) Initialize(_ *interop.Context) error { return nil } // PutContractState saves given contract state into given DAO. func (m *Management) PutContractState(d dao.DAO, cs *state.Contract) error { key := makeContractKey(cs.Hash) if err := putSerializableToDAO(m.ContractID, d, key, cs); err != nil { return err } if cs.UpdateCounter != 0 { // Update. return nil } return d.PutContractID(cs.ID, cs.Hash) } func (m *Management) getNextContractID(d dao.DAO) (int32, error) { var id = big.NewInt(1) si := d.GetStorageItem(m.ContractID, keyNextAvailableID) if si != nil { id = bigint.FromBytes(si.Value) } else { si = new(state.StorageItem) si.Value = make([]byte, 0, 2) } ret := int32(id.Int64()) id.Add(id, big.NewInt(1)) si.Value = bigint.ToPreallocatedBytes(id, si.Value) return ret, d.PutStorageItem(m.ContractID, keyNextAvailableID, si) }