From e1d2a5b5b7cd04f9beb6b36b8771ebf773bb60cc Mon Sep 17 00:00:00 2001 From: Evgeniy Stratonikov Date: Tue, 9 Feb 2021 12:02:38 +0300 Subject: [PATCH 1/5] state: split ContractBase and UpdateCounter Latter doesn't make sense for native contracts. --- pkg/compiler/interop_test.go | 16 ++++++++------ pkg/core/interop_neo_test.go | 10 +++++---- pkg/core/interop_system_test.go | 36 +++++++++++++++++++------------- pkg/core/native/management.go | 20 +++++++++++------- pkg/core/native_contract_test.go | 28 +++++++++++++++---------- pkg/core/native_oracle_test.go | 10 +++++---- pkg/core/state/contract.go | 15 ++++++++----- pkg/core/state/contract_test.go | 22 ++++++++++--------- pkg/rpc/client/rpc_test.go | 30 +++++++++++++++----------- 9 files changed, 113 insertions(+), 74 deletions(-) diff --git a/pkg/compiler/interop_test.go b/pkg/compiler/interop_test.go index cb0504e07..8f91cfca1 100644 --- a/pkg/compiler/interop_test.go +++ b/pkg/compiler/interop_test.go @@ -166,17 +166,21 @@ func TestAppCall(t *testing.T) { innerNef, err := nef.NewFile(inner) require.NoError(t, err) return &state.Contract{ - Hash: ih, - NEF: *innerNef, - Manifest: *m, + ContractBase: state.ContractBase{ + Hash: ih, + NEF: *innerNef, + Manifest: *m, + }, }, nil } else if h.Equals(barH) { barNef, err := nef.NewFile(barCtr) require.NoError(t, err) return &state.Contract{ - Hash: barH, - NEF: *barNef, - Manifest: *mBar, + ContractBase: state.ContractBase{ + Hash: barH, + NEF: *barNef, + Manifest: *mBar, + }, }, nil } return nil, errors.New("not found") diff --git a/pkg/core/interop_neo_test.go b/pkg/core/interop_neo_test.go index a7763ee24..463ad4bae 100644 --- a/pkg/core/interop_neo_test.go +++ b/pkg/core/interop_neo_test.go @@ -262,10 +262,12 @@ func createVMAndContractState(t *testing.T) (*vm.VM, *state.Contract, *interop.C ne, err := nef.NewFile(script) require.NoError(t, err) contractState := &state.Contract{ - NEF: *ne, - Hash: hash.Hash160(script), - Manifest: *m, - ID: 123, + ContractBase: state.ContractBase{ + NEF: *ne, + Hash: hash.Hash160(script), + Manifest: *m, + ID: 123, + }, } chain := newTestChain(t) diff --git a/pkg/core/interop_system_test.go b/pkg/core/interop_system_test.go index c7e893467..461216970 100644 --- a/pkg/core/interop_system_test.go +++ b/pkg/core/interop_system_test.go @@ -68,7 +68,8 @@ func TestContractIsStandard(t *testing.T) { pub := priv.PublicKey() ne, err := nef.NewFile(pub.GetVerificationScript()) require.NoError(t, err) - err = chain.contracts.Management.PutContractState(ic.DAO, &state.Contract{ID: 42, Hash: pub.GetScriptHash(), NEF: *ne}) + err = chain.contracts.Management.PutContractState(ic.DAO, + &state.Contract{ContractBase: state.ContractBase{ID: 42, Hash: pub.GetScriptHash(), NEF: *ne}}) require.NoError(t, err) v.Estack().PushVal(pub.GetScriptHash().BytesBE()) @@ -79,7 +80,8 @@ func TestContractIsStandard(t *testing.T) { script := []byte{byte(opcode.PUSHT)} ne, err := nef.NewFile(script) require.NoError(t, err) - require.NoError(t, chain.contracts.Management.PutContractState(ic.DAO, &state.Contract{ID: 24, Hash: hash.Hash160(script), NEF: *ne})) + require.NoError(t, chain.contracts.Management.PutContractState(ic.DAO, + &state.Contract{ContractBase: state.ContractBase{ID: 24, Hash: hash.Hash160(script), NEF: *ne}})) v.Estack().PushVal(crypto.Hash160(script).BytesBE()) require.NoError(t, contractIsStandard(ic)) @@ -540,9 +542,11 @@ func getTestContractState(bc *Blockchain) (*state.Contract, *state.Contract) { m.Permissions[1].Methods.Add("method") cs := &state.Contract{ - Hash: h, - Manifest: *m, - ID: 42, + ContractBase: state.ContractBase{ + Hash: h, + Manifest: *m, + ID: 42, + }, } ne, err := nef.NewFile(script) if err != nil { @@ -582,10 +586,12 @@ func getTestContractState(bc *Blockchain) (*state.Contract, *state.Contract) { } return cs, &state.Contract{ - NEF: *ne, - Hash: hash.Hash160(currScript), - Manifest: *m, - ID: 123, + ContractBase: state.ContractBase{ + NEF: *ne, + Hash: hash.Hash160(currScript), + Manifest: *m, + ID: 123, + }, } } @@ -906,11 +912,13 @@ func TestRuntimeCheckWitness(t *testing.T) { ne, err := nef.NewFile(contractScript) require.NoError(t, err) contractState := &state.Contract{ - ID: 15, - Hash: contractScriptHash, - NEF: *ne, - Manifest: manifest.Manifest{ - Groups: []manifest.Group{{PublicKey: pk.PublicKey(), Signature: make([]byte, keys.SignatureLen)}}, + ContractBase: state.ContractBase{ + ID: 15, + Hash: contractScriptHash, + NEF: *ne, + Manifest: manifest.Manifest{ + Groups: []manifest.Group{{PublicKey: pk.PublicKey(), Signature: make([]byte, keys.SignatureLen)}}, + }, }, } require.NoError(t, bc.contracts.Management.PutContractState(ic.DAO, contractState)) diff --git a/pkg/core/native/management.go b/pkg/core/native/management.go index 6aded9512..b2a947ae8 100644 --- a/pkg/core/native/management.go +++ b/pkg/core/native/management.go @@ -280,10 +280,12 @@ func (m *Management) Deploy(d dao.DAO, sender util.Uint160, neff *nef.File, mani return nil, err } newcontract := &state.Contract{ - ID: id, - Hash: h, - NEF: *neff, - Manifest: *manif, + ContractBase: state.ContractBase{ + ID: id, + Hash: h, + NEF: *neff, + Manifest: *manif, + }, } err = m.PutContractState(d, newcontract) if err != nil { @@ -451,10 +453,12 @@ func (m *Management) OnPersist(ic *interop.Context) error { md := native.Metadata() cs := &state.Contract{ - ID: md.ContractID, - Hash: md.Hash, - NEF: md.NEF, - Manifest: md.Manifest, + ContractBase: state.ContractBase{ + ID: md.ContractID, + Hash: md.Hash, + NEF: md.NEF, + Manifest: md.Manifest, + }, } err := m.PutContractState(ic.DAO, cs) if err != nil { diff --git a/pkg/core/native_contract_test.go b/pkg/core/native_contract_test.go index d5002e367..4aeb62d3f 100644 --- a/pkg/core/native_contract_test.go +++ b/pkg/core/native_contract_test.go @@ -172,10 +172,12 @@ func TestNativeContract_Invoke(t *testing.T) { chain.registerNative(tn) err := chain.contracts.Management.PutContractState(chain.dao, &state.Contract{ - ID: 1, - NEF: tn.meta.NEF, - Hash: tn.meta.Hash, - Manifest: tn.meta.Manifest, + ContractBase: state.ContractBase{ + ID: 1, + NEF: tn.meta.NEF, + Hash: tn.meta.Hash, + Manifest: tn.meta.Manifest, + }, }) require.NoError(t, err) @@ -210,9 +212,11 @@ func TestNativeContract_InvokeInternal(t *testing.T) { chain.registerNative(tn) err := chain.contracts.Management.PutContractState(chain.dao, &state.Contract{ - ID: 1, - NEF: tn.meta.NEF, - Manifest: tn.meta.Manifest, + ContractBase: state.ContractBase{ + ID: 1, + NEF: tn.meta.NEF, + Manifest: tn.meta.Manifest, + }, }) require.NoError(t, err) @@ -253,10 +257,12 @@ func TestNativeContract_InvokeOtherContract(t *testing.T) { chain.registerNative(tn) err := chain.contracts.Management.PutContractState(chain.dao, &state.Contract{ - ID: 1, - Hash: tn.meta.Hash, - NEF: tn.meta.NEF, - Manifest: tn.meta.Manifest, + ContractBase: state.ContractBase{ + ID: 1, + Hash: tn.meta.Hash, + NEF: tn.meta.NEF, + Manifest: tn.meta.Manifest, + }, }) require.NoError(t, err) diff --git a/pkg/core/native_oracle_test.go b/pkg/core/native_oracle_test.go index a99aa2c76..38671ad52 100644 --- a/pkg/core/native_oracle_test.go +++ b/pkg/core/native_oracle_test.go @@ -92,10 +92,12 @@ func getOracleContractState(h util.Uint160) *state.Contract { panic(err) } return &state.Contract{ - NEF: *ne, - Hash: hash.Hash160(script), - Manifest: *m, - ID: 42, + ContractBase: state.ContractBase{ + NEF: *ne, + Hash: hash.Hash160(script), + Manifest: *m, + ID: 42, + }, } } diff --git a/pkg/core/state/contract.go b/pkg/core/state/contract.go index b477676b0..a9b94612d 100644 --- a/pkg/core/state/contract.go +++ b/pkg/core/state/contract.go @@ -18,11 +18,16 @@ import ( // Contract holds information about a smart contract in the NEO blockchain. type Contract struct { - ID int32 `json:"id"` - UpdateCounter uint16 `json:"updatecounter"` - Hash util.Uint160 `json:"hash"` - NEF nef.File `json:"nef"` - Manifest manifest.Manifest `json:"manifest"` + ContractBase + UpdateCounter uint16 `json:"updatecounter"` +} + +// ContractBase represents part shared by native and user-deployed contracts. +type ContractBase struct { + ID int32 `json:"id"` + Hash util.Uint160 `json:"hash"` + NEF nef.File `json:"nef"` + Manifest manifest.Manifest `json:"manifest"` } // DecodeBinary implements Serializable interface. diff --git a/pkg/core/state/contract_test.go b/pkg/core/state/contract_test.go index c64fb9636..d2c7987ec 100644 --- a/pkg/core/state/contract_test.go +++ b/pkg/core/state/contract_test.go @@ -34,19 +34,21 @@ func TestEncodeDecodeContractState(t *testing.T) { ReturnType: smartcontract.BoolType, }} contract := &Contract{ - ID: 123, UpdateCounter: 42, - Hash: h, - NEF: nef.File{ - Header: nef.Header{ - Magic: nef.Magic, - Compiler: "neo-go.test-test", + ContractBase: ContractBase{ + ID: 123, + Hash: h, + NEF: nef.File{ + Header: nef.Header{ + Magic: nef.Magic, + Compiler: "neo-go.test-test", + }, + Tokens: []nef.MethodToken{}, + Script: script, + Checksum: 0, }, - Tokens: []nef.MethodToken{}, - Script: script, - Checksum: 0, + Manifest: *m, }, - Manifest: *m, } contract.NEF.Checksum = contract.NEF.CalculateChecksum() diff --git a/pkg/rpc/client/rpc_test.go b/pkg/rpc/client/rpc_test.go index d861c12b4..30c849233 100644 --- a/pkg/rpc/client/rpc_test.go +++ b/pkg/rpc/client/rpc_test.go @@ -350,10 +350,12 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{ } m := manifest.NewManifest("Test") cs := &state.Contract{ - ID: 0, - Hash: hash.Hash160(script), - NEF: newTestNEF(script), - Manifest: *m, + ContractBase: state.ContractBase{ + ID: 0, + Hash: hash.Hash160(script), + NEF: newTestNEF(script), + Manifest: *m, + }, } return cs }, @@ -371,10 +373,12 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{ } m := manifest.NewManifest("Test") cs := &state.Contract{ - ID: 0, - Hash: hash.Hash160(script), - NEF: newTestNEF(script), - Manifest: *m, + ContractBase: state.ContractBase{ + ID: 0, + Hash: hash.Hash160(script), + NEF: newTestNEF(script), + Manifest: *m, + }, } return cs }, @@ -392,10 +396,12 @@ var rpcClientTestCases = map[string][]rpcClientTestCase{ } m := manifest.NewManifest("Test") cs := &state.Contract{ - ID: 0, - Hash: hash.Hash160(script), - NEF: newTestNEF(script), - Manifest: *m, + ContractBase: state.ContractBase{ + ID: 0, + Hash: hash.Hash160(script), + NEF: newTestNEF(script), + Manifest: *m, + }, } return cs }, From f0d8652bcdb6294139f727a5880b4f85f06553f7 Mon Sep 17 00:00:00 2001 From: Evgeniy Stratonikov Date: Tue, 9 Feb 2021 12:25:38 +0300 Subject: [PATCH 2/5] rpc: implement `getnativecontracts` RPC --- internal/fakechain/fakechain.go | 5 +++++ pkg/core/blockchain.go | 13 +++++++++++++ pkg/core/blockchainer/blockchainer.go | 1 + pkg/core/state/contract.go | 6 ++++++ pkg/rpc/server/server.go | 5 +++++ pkg/rpc/server/server_test.go | 16 ++++++++++++++++ 6 files changed, 46 insertions(+) diff --git a/internal/fakechain/fakechain.go b/internal/fakechain/fakechain.go index 97d690a6c..0489a46fd 100644 --- a/internal/fakechain/fakechain.go +++ b/internal/fakechain/fakechain.go @@ -85,6 +85,11 @@ func (*FakeChain) IsExtensibleAllowed(uint160 util.Uint160) bool { return true } +// GetNatives implements blockchainer.Blockchainer interface. +func (*FakeChain) GetNatives() []state.NativeContract { + panic("TODO") +} + // GetNotaryDepositExpiration implements Blockchainer interface. func (chain *FakeChain) GetNotaryDepositExpiration(acc util.Uint160) uint32 { if chain.NotaryDepositExpiration != 0 { diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go index 4fd1a5857..56c8c8666 100644 --- a/pkg/core/blockchain.go +++ b/pkg/core/blockchain.go @@ -1243,6 +1243,19 @@ func (bc *Blockchain) GetNativeContractScriptHash(name string) (util.Uint160, er return util.Uint160{}, errors.New("Unknown native contract") } +// GetNatives returns list of native contracts. +func (bc *Blockchain) GetNatives() []state.NativeContract { + res := make([]state.NativeContract, len(bc.contracts.Contracts)) + for i, c := range bc.contracts.Contracts { + md := c.Metadata() + res[i].ID = md.ContractID + res[i].Hash = md.Hash + res[i].Manifest = md.Manifest + res[i].NEF = md.NEF + } + return res +} + // GetConfig returns the config stored in the blockchain. func (bc *Blockchain) GetConfig() config.ProtocolConfiguration { return bc.config diff --git a/pkg/core/blockchainer/blockchainer.go b/pkg/core/blockchainer/blockchainer.go index 9dad9966c..24ed60289 100644 --- a/pkg/core/blockchainer/blockchainer.go +++ b/pkg/core/blockchainer/blockchainer.go @@ -45,6 +45,7 @@ type Blockchainer interface { GetAppExecResults(util.Uint256, trigger.Type) ([]state.AppExecResult, error) GetNotaryDepositExpiration(acc util.Uint160) uint32 GetNativeContractScriptHash(string) (util.Uint160, error) + GetNatives() []state.NativeContract GetNextBlockValidators() ([]*keys.PublicKey, error) GetNEP17Balances(util.Uint160) *state.NEP17Balances GetNotaryContractScriptHash() util.Uint160 diff --git a/pkg/core/state/contract.go b/pkg/core/state/contract.go index a9b94612d..7e0dd435c 100644 --- a/pkg/core/state/contract.go +++ b/pkg/core/state/contract.go @@ -30,6 +30,12 @@ type ContractBase struct { Manifest manifest.Manifest `json:"manifest"` } +// NativeContract holds information about native contract. +type NativeContract struct { + ContractBase + ActiveBlockIndex uint32 `json:"activeblockindex"` +} + // DecodeBinary implements Serializable interface. func (c *Contract) DecodeBinary(r *io.BinReader) { si := stackitem.DecodeBinaryStackItem(r) diff --git a/pkg/rpc/server/server.go b/pkg/rpc/server/server.go index f7d7349c9..2adaae5dd 100644 --- a/pkg/rpc/server/server.go +++ b/pkg/rpc/server/server.go @@ -103,6 +103,7 @@ var rpcHandlers = map[string]func(*Server, request.Params) (interface{}, *respon "getcommittee": (*Server).getCommittee, "getconnectioncount": (*Server).getConnectionCount, "getcontractstate": (*Server).getContractState, + "getnativecontracts": (*Server).getNativeContracts, "getnep17balances": (*Server).getNEP17Balances, "getnep17transfers": (*Server).getNEP17Transfers, "getpeers": (*Server).getPeers, @@ -986,6 +987,10 @@ func (s *Server) getContractState(reqParams request.Params) (interface{}, *respo return cs, nil } +func (s *Server) getNativeContracts(_ request.Params) (interface{}, *response.Error) { + return s.chain.GetNatives(), nil +} + // getBlockSysFee returns the system fees of the block, based on the specified index. func (s *Server) getBlockSysFee(reqParams request.Params) (interface{}, *response.Error) { param := reqParams.ValueWithType(0, request.NumberT) diff --git a/pkg/rpc/server/server_test.go b/pkg/rpc/server/server_test.go index fe5a102d0..fc68ae6e3 100644 --- a/pkg/rpc/server/server_test.go +++ b/pkg/rpc/server/server_test.go @@ -552,6 +552,22 @@ var rpcTestCases = map[string][]rpcTestCase{ }, }, }, + "getnativecontracts": { + { + params: "[]", + result: func(e *executor) interface{} { + return new([]state.NativeContract) + }, + check: func(t *testing.T, e *executor, res interface{}) { + lst := res.(*[]state.NativeContract) + for i := range *lst { + cs := e.chain.GetContractState((*lst)[i].Hash) + require.NotNil(t, cs) + require.True(t, cs.ID <= 0) + } + }, + }, + }, "getpeers": { { params: "[]", From 6ca7b4b966edcf7cab4785b6b5fb9fc82f12548a Mon Sep 17 00:00:00 2001 From: Evgeniy Stratonikov Date: Tue, 9 Feb 2021 12:26:25 +0300 Subject: [PATCH 3/5] interop: rename `ContractID` to `ID` Helps further refactoring, see next commit. --- pkg/core/blockchain.go | 8 ++--- pkg/core/helper_test.go | 2 +- pkg/core/interop/context.go | 18 +++++----- pkg/core/native/designate.go | 6 ++-- pkg/core/native/interop.go | 2 +- pkg/core/native/management.go | 24 ++++++------- pkg/core/native/management_test.go | 2 +- pkg/core/native/name_service.go | 48 ++++++++++++------------- pkg/core/native/native_neo.go | 50 +++++++++++++------------- pkg/core/native/native_nep17.go | 16 ++++----- pkg/core/native/nonfungible.go | 26 +++++++------- pkg/core/native/notary.go | 14 ++++---- pkg/core/native/oracle.go | 22 ++++++------ pkg/core/native/policy.go | 56 +++++++++++++++--------------- pkg/core/native_contract_test.go | 2 +- 15 files changed, 148 insertions(+), 148 deletions(-) diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go index 56c8c8666..7fa8478a5 100644 --- a/pkg/core/blockchain.go +++ b/pkg/core/blockchain.go @@ -920,7 +920,7 @@ func (bc *Blockchain) processNEP17Transfer(cache *dao.Cached, h util.Uint256, b var id int32 nativeContract := bc.contracts.ByHash(sc) if nativeContract != nil { - id = nativeContract.Metadata().ContractID + id = nativeContract.Metadata().ID } else { assetContract, err := bc.contracts.Management.GetContract(cache, sc) if err != nil { @@ -1018,7 +1018,7 @@ func (bc *Blockchain) GetUtilityTokenBalance(acc util.Uint160) *big.Int { if err != nil { return big.NewInt(0) } - balance := bs.Trackers[bc.contracts.GAS.ContractID].Balance + balance := bs.Trackers[bc.contracts.GAS.ID].Balance return &balance } @@ -1029,7 +1029,7 @@ func (bc *Blockchain) GetGoverningTokenBalance(acc util.Uint160) (*big.Int, uint if err != nil { return big.NewInt(0), 0 } - neo := bs.Trackers[bc.contracts.NEO.ContractID] + neo := bs.Trackers[bc.contracts.NEO.ID] return &neo.Balance, neo.LastUpdatedBlock } @@ -1248,7 +1248,7 @@ func (bc *Blockchain) GetNatives() []state.NativeContract { res := make([]state.NativeContract, len(bc.contracts.Contracts)) for i, c := range bc.contracts.Contracts { md := c.Metadata() - res[i].ID = md.ContractID + res[i].ID = md.ID res[i].Hash = md.Hash res[i].Manifest = md.Manifest res[i].NEF = md.NEF diff --git a/pkg/core/helper_test.go b/pkg/core/helper_test.go index 3b48f1841..3fc97d8ea 100644 --- a/pkg/core/helper_test.go +++ b/pkg/core/helper_test.go @@ -589,7 +589,7 @@ func checkFAULTState(t *testing.T, result *state.AppExecResult) { } func checkBalanceOf(t *testing.T, chain *Blockchain, addr util.Uint160, expected int) { - balance := chain.GetNEP17Balances(addr).Trackers[chain.contracts.GAS.ContractID] + balance := chain.GetNEP17Balances(addr).Trackers[chain.contracts.GAS.ID] require.Equal(t, int64(expected), balance.Balance.Int64()) } diff --git a/pkg/core/interop/context.go b/pkg/core/interop/context.go index 0d00d3e10..c10d31933 100644 --- a/pkg/core/interop/context.go +++ b/pkg/core/interop/context.go @@ -99,12 +99,12 @@ type Contract interface { // ContractMD represents native contract instance. type ContractMD struct { - Manifest manifest.Manifest - Name string - ContractID int32 - NEF nef.File - Hash util.Uint160 - Methods map[MethodAndArgCount]MethodAndPrice + Manifest manifest.Manifest + Name string + ID int32 + NEF nef.File + Hash util.Uint160 + Methods map[MethodAndArgCount]MethodAndPrice } // MethodAndArgCount represents method's signature. @@ -116,9 +116,9 @@ type MethodAndArgCount struct { // NewContractMD returns Contract with the specified list of methods. func NewContractMD(name string, id int32) *ContractMD { c := &ContractMD{ - Name: name, - ContractID: id, - Methods: make(map[MethodAndArgCount]MethodAndPrice), + Name: name, + ID: id, + Methods: make(map[MethodAndArgCount]MethodAndPrice), } // NEF is now stored in contract state and affects state dump. diff --git a/pkg/core/native/designate.go b/pkg/core/native/designate.go index 07680ce7a..ce8c1bdc9 100644 --- a/pkg/core/native/designate.go +++ b/pkg/core/native/designate.go @@ -242,7 +242,7 @@ func (s *Designate) GetDesignatedByRole(d dao.DAO, r Role, index uint32) (keys.P return val.nodes.Copy(), val.height, nil } } - kvs, err := d.GetStorageItemsWithPrefix(s.ContractID, []byte{byte(r)}) + kvs, err := d.GetStorageItemsWithPrefix(s.ID, []byte{byte(r)}) if err != nil { return nil, 0, err } @@ -309,14 +309,14 @@ func (s *Designate) DesignateAsRole(ic *interop.Context, r Role, pubs keys.Publi key[0] = byte(r) binary.BigEndian.PutUint32(key[1:], ic.Block.Index+1) - si := ic.DAO.GetStorageItem(s.ContractID, key) + si := ic.DAO.GetStorageItem(s.ID, key) if si != nil { return ErrAlreadyDesignated } sort.Sort(pubs) s.rolesChangedFlag.Store(true) si = &state.StorageItem{Value: NodeList(pubs).Bytes()} - return ic.DAO.PutStorageItem(s.ContractID, key, si) + return ic.DAO.PutStorageItem(s.ID, key, si) } func (s *Designate) getRole(item stackitem.Item) (Role, bool) { diff --git a/pkg/core/native/interop.go b/pkg/core/native/interop.go index c4fb5744d..340b0d3c9 100644 --- a/pkg/core/native/interop.go +++ b/pkg/core/native/interop.go @@ -15,7 +15,7 @@ func Call(ic *interop.Context) error { id := int32(ic.VM.Estack().Pop().BigInt().Int64()) var c interop.Contract for _, ctr := range ic.Natives { - if ctr.Metadata().ContractID == id { + if ctr.Metadata().ID == id { c = ctr break } diff --git a/pkg/core/native/management.go b/pkg/core/native/management.go index b2a947ae8..8145c8405 100644 --- a/pkg/core/native/management.go +++ b/pkg/core/native/management.go @@ -151,7 +151,7 @@ func (m *Management) GetContract(d dao.DAO, hash util.Uint160) (*state.Contract, func (m *Management) getContractFromDAO(d dao.DAO, hash util.Uint160) (*state.Contract, error) { contract := new(state.Contract) key := makeContractKey(hash) - err := getSerializableFromDAO(m.ContractID, d, key, contract) + err := getSerializableFromDAO(m.ID, d, key, contract) if err != nil { return nil, err } @@ -263,7 +263,7 @@ func (m *Management) markUpdated(h util.Uint160) { func (m *Management) Deploy(d dao.DAO, sender util.Uint160, neff *nef.File, manif *manifest.Manifest) (*state.Contract, error) { h := state.CreateContractHash(sender, neff.Checksum, manif.Name) key := makeContractKey(h) - si := d.GetStorageItem(m.ContractID, key) + si := d.GetStorageItem(m.ID, key) if si != nil { return nil, errors.New("contract already exists") } @@ -373,7 +373,7 @@ func (m *Management) Destroy(d dao.DAO, hash util.Uint160) error { return err } key := makeContractKey(hash) - err = d.DeleteStorageItem(m.ContractID, key) + err = d.DeleteStorageItem(m.ID, key) if err != nil { return err } @@ -401,7 +401,7 @@ func (m *Management) getMinimumDeploymentFee(ic *interop.Context, args []stackit // GetMinimumDeploymentFee returns the minimum required fee for contract deploy. func (m *Management) GetMinimumDeploymentFee(dao dao.DAO) int64 { - return getIntWithKey(m.ContractID, dao, keyMinimumDeploymentFee) + return getIntWithKey(m.ID, dao, keyMinimumDeploymentFee) } func (m *Management) setMinimumDeploymentFee(ic *interop.Context, args []stackitem.Item) stackitem.Item { @@ -412,7 +412,7 @@ func (m *Management) setMinimumDeploymentFee(ic *interop.Context, args []stackit if !m.NEO.checkCommittee(ic) { panic("invalid committee signature") } - err := setIntWithKey(m.ContractID, ic.DAO, keyMinimumDeploymentFee, int64(value)) + err := setIntWithKey(m.ID, ic.DAO, keyMinimumDeploymentFee, int64(value)) if err != nil { panic(err) } @@ -454,7 +454,7 @@ func (m *Management) OnPersist(ic *interop.Context) error { cs := &state.Contract{ ContractBase: state.ContractBase{ - ID: md.ContractID, + ID: md.ID, Hash: md.Hash, NEF: md.NEF, Manifest: md.Manifest, @@ -483,7 +483,7 @@ func (m *Management) InitializeCache(d dao.DAO) error { defer m.mtx.Unlock() var initErr error - d.Seek(m.ContractID, []byte{prefixContract}, func(_, v []byte) { + d.Seek(m.ID, []byte{prefixContract}, func(_, v []byte) { var r = io.NewBinReaderFromBuf(v) var si state.StorageItem si.DecodeBinary(r) @@ -525,16 +525,16 @@ func (m *Management) PostPersist(ic *interop.Context) error { // Initialize implements Contract interface. func (m *Management) Initialize(ic *interop.Context) error { - if err := setIntWithKey(m.ContractID, ic.DAO, keyMinimumDeploymentFee, defaultMinimumDeploymentFee); err != nil { + if err := setIntWithKey(m.ID, ic.DAO, keyMinimumDeploymentFee, defaultMinimumDeploymentFee); err != nil { return err } - return setIntWithKey(m.ContractID, ic.DAO, keyNextAvailableID, 1) + return setIntWithKey(m.ID, ic.DAO, keyNextAvailableID, 1) } // 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 { + if err := putSerializableToDAO(m.ID, d, key, cs); err != nil { return err } m.markUpdated(cs.Hash) @@ -545,7 +545,7 @@ func (m *Management) PutContractState(d dao.DAO, cs *state.Contract) error { } func (m *Management) getNextContractID(d dao.DAO) (int32, error) { - si := d.GetStorageItem(m.ContractID, keyNextAvailableID) + si := d.GetStorageItem(m.ID, keyNextAvailableID) if si == nil { return 0, errors.New("nextAvailableID is not initialized") @@ -554,7 +554,7 @@ func (m *Management) getNextContractID(d dao.DAO) (int32, error) { ret := int32(id.Int64()) id.Add(id, intOne) si.Value = bigint.ToPreallocatedBytes(id, si.Value) - return ret, d.PutStorageItem(m.ContractID, keyNextAvailableID, si) + return ret, d.PutStorageItem(m.ID, keyNextAvailableID, si) } func (m *Management) emitNotification(ic *interop.Context, name string, hash util.Uint160) { diff --git a/pkg/core/native/management_test.go b/pkg/core/native/management_test.go index 7dfa4c054..05a9894c1 100644 --- a/pkg/core/native/management_test.go +++ b/pkg/core/native/management_test.go @@ -79,7 +79,7 @@ func TestManagement_Initialize(t *testing.T) { t.Run("invalid contract state", func(t *testing.T) { d := dao.NewSimple(storage.NewMemoryStore(), netmode.UnitTestNet, false) mgmt := newManagement() - require.NoError(t, d.PutStorageItem(mgmt.ContractID, []byte{prefixContract}, &state.StorageItem{Value: []byte{0xFF}})) + require.NoError(t, d.PutStorageItem(mgmt.ID, []byte{prefixContract}, &state.StorageItem{Value: []byte{0xFF}})) require.Error(t, mgmt.InitializeCache(d)) }) } diff --git a/pkg/core/native/name_service.go b/pkg/core/native/name_service.go index 844fa2cff..21c5af1a1 100644 --- a/pkg/core/native/name_service.go +++ b/pkg/core/native/name_service.go @@ -175,18 +175,18 @@ func (n *NameService) Initialize(ic *interop.Context) error { if err := n.nonfungible.Initialize(ic); err != nil { return err } - if err := setIntWithKey(n.ContractID, ic.DAO, []byte{prefixDomainPrice}, DefaultDomainPrice); err != nil { + if err := setIntWithKey(n.ID, ic.DAO, []byte{prefixDomainPrice}, DefaultDomainPrice); err != nil { return err } roots := stringList{} - return putSerializableToDAO(n.ContractID, ic.DAO, []byte{prefixRoots}, &roots) + return putSerializableToDAO(n.ID, ic.DAO, []byte{prefixRoots}, &roots) } // OnPersist implements interop.Contract interface. func (n *NameService) OnPersist(ic *interop.Context) error { now := uint32(ic.Block.Timestamp/1000 + 1) keys := []string{} - ic.DAO.Seek(n.ContractID, []byte{prefixExpiration}, func(k, v []byte) { + ic.DAO.Seek(n.ID, []byte{prefixExpiration}, func(k, v []byte) { if binary.BigEndian.Uint32(k) >= now { return } @@ -200,20 +200,20 @@ func (n *NameService) OnPersist(ic *interop.Context) error { for i := range keys { key[0] = prefixExpiration key = append(key[:1], []byte(keys[i])...) - if err := ic.DAO.DeleteStorageItem(n.ContractID, key); err != nil { + if err := ic.DAO.DeleteStorageItem(n.ID, key); err != nil { return err } keysToRemove = keysToRemove[:0] key[0] = prefixRecord key = append(key[:1], keys[i][4:]...) - ic.DAO.Seek(n.ContractID, key, func(k, v []byte) { + ic.DAO.Seek(n.ID, key, func(k, v []byte) { keysToRemove = append(keysToRemove, k) }) for i := range keysToRemove { keyRecord = append(keyRecord[:0], key...) keyRecord = append(keyRecord, keysToRemove[i]...) - err := ic.DAO.DeleteStorageItem(n.ContractID, keyRecord) + err := ic.DAO.DeleteStorageItem(n.ID, keyRecord) if err != nil { return err } @@ -242,7 +242,7 @@ func (n *NameService) addRoot(ic *interop.Context, args []stackitem.Item) stacki panic("name already exists") } - err := putSerializableToDAO(n.ContractID, ic.DAO, []byte{prefixRoots}, &roots) + err := putSerializableToDAO(n.ID, ic.DAO, []byte{prefixRoots}, &roots) if err != nil { panic(err) } @@ -259,7 +259,7 @@ func (n *NameService) setPrice(ic *interop.Context, args []stackitem.Item) stack n.checkCommittee(ic) si := &state.StorageItem{Value: bigint.ToBytes(price)} - err := ic.DAO.PutStorageItem(n.ContractID, []byte{prefixDomainPrice}, si) + err := ic.DAO.PutStorageItem(n.ID, []byte{prefixDomainPrice}, si) if err != nil { panic(err) } @@ -271,7 +271,7 @@ func (n *NameService) getPrice(ic *interop.Context, _ []stackitem.Item) stackite } func (n *NameService) getPriceInternal(d dao.DAO) *big.Int { - si := d.GetStorageItem(n.ContractID, []byte{prefixDomainPrice}) + si := d.GetStorageItem(n.ID, []byte{prefixDomainPrice}) return bigint.FromBytes(si.Value) } @@ -286,7 +286,7 @@ func (n *NameService) parseName(item stackitem.Item) (string, []string, []byte) func (n *NameService) isAvailable(ic *interop.Context, args []stackitem.Item) stackitem.Item { _, names, key := n.parseName(args[0]) - if ic.DAO.GetStorageItem(n.ContractID, key) != nil { + if ic.DAO.GetStorageItem(n.ID, key) != nil { return stackitem.NewBool(false) } @@ -300,7 +300,7 @@ func (n *NameService) isAvailable(ic *interop.Context, args []stackitem.Item) st func (n *NameService) getRootsInternal(d dao.DAO) (stringList, bool) { var sl stringList - err := getSerializableFromDAO(n.ContractID, d, []byte{prefixRoots}, &sl) + err := getSerializableFromDAO(n.ID, d, []byte{prefixRoots}, &sl) if err != nil { // Roots are being stored in `Initialize()` and thus must always be present. panic(err) @@ -315,7 +315,7 @@ func (n *NameService) register(ic *interop.Context, args []stackitem.Item) stack panic("owner is not witnessed") } - if ic.DAO.GetStorageItem(n.ContractID, key) != nil { + if ic.DAO.GetStorageItem(n.ID, key) != nil { return stackitem.NewBool(false) } @@ -334,7 +334,7 @@ func (n *NameService) register(ic *interop.Context, args []stackitem.Item) stack Expiration: uint32(ic.Block.Timestamp/1000 + secondsInYear), } n.mint(ic, token) - err := ic.DAO.PutStorageItem(n.ContractID, + err := ic.DAO.PutStorageItem(n.ID, makeExpirationKey(token.Expiration, token.ID()), &state.StorageItem{Value: []byte{0}}) if err != nil { @@ -349,25 +349,25 @@ func (n *NameService) renew(ic *interop.Context, args []stackitem.Item) stackite panic("insufficient gas") } token := new(nameState) - err := getSerializableFromDAO(n.ContractID, ic.DAO, key, token) + err := getSerializableFromDAO(n.ID, ic.DAO, key, token) if err != nil { panic(err) } keyExpiration := makeExpirationKey(token.Expiration, token.ID()) - if err := ic.DAO.DeleteStorageItem(n.ContractID, keyExpiration); err != nil { + if err := ic.DAO.DeleteStorageItem(n.ID, keyExpiration); err != nil { panic(err) } token.Expiration += secondsInYear - err = putSerializableToDAO(n.ContractID, ic.DAO, key, token) + err = putSerializableToDAO(n.ID, ic.DAO, key, token) if err != nil { panic(err) } binary.BigEndian.PutUint32(key[1:], token.Expiration) si := &state.StorageItem{Value: []byte{0}} - err = ic.DAO.PutStorageItem(n.ContractID, key, si) + err = ic.DAO.PutStorageItem(n.ID, key, si) if err != nil { panic(err) } @@ -388,7 +388,7 @@ func (n *NameService) setAdmin(ic *interop.Context, args []stackitem.Item) stack } token := new(nameState) - err := getSerializableFromDAO(n.ContractID, ic.DAO, key, token) + err := getSerializableFromDAO(n.ID, ic.DAO, key, token) if err != nil { panic(err) } @@ -397,7 +397,7 @@ func (n *NameService) setAdmin(ic *interop.Context, args []stackitem.Item) stack } token.HasAdmin = !isNull token.Admin = admin - err = putSerializableToDAO(n.ContractID, ic.DAO, key, token) + err = putSerializableToDAO(n.ID, ic.DAO, key, token) if err != nil { panic(err) } @@ -441,7 +441,7 @@ func (n *NameService) setRecord(ic *interop.Context, args []stackitem.Item) stac } key := makeRecordKey(domain, name, rt) si := &state.StorageItem{Value: []byte(data)} - if err := ic.DAO.PutStorageItem(n.ContractID, key, si); err != nil { + if err := ic.DAO.PutStorageItem(n.ID, key, si); err != nil { panic(err) } return stackitem.Null{} @@ -473,7 +473,7 @@ func (n *NameService) getRecord(ic *interop.Context, args []stackitem.Item) stac domain := toDomain(name) rt := toRecordType(args[1]) key := makeRecordKey(domain, name, rt) - si := ic.DAO.GetStorageItem(n.ContractID, key) + si := ic.DAO.GetStorageItem(n.ID, key) if si == nil { return stackitem.Null{} } @@ -486,7 +486,7 @@ func (n *NameService) deleteRecord(ic *interop.Context, args []stackitem.Item) s domain := toDomain(name) key := n.getTokenKey([]byte(domain)) token := new(nameState) - err := getSerializableFromDAO(n.ContractID, ic.DAO, key, token) + err := getSerializableFromDAO(n.ID, ic.DAO, key, token) if err != nil { panic(err) } @@ -496,7 +496,7 @@ func (n *NameService) deleteRecord(ic *interop.Context, args []stackitem.Item) s } key = makeRecordKey(domain, name, rt) - if err := ic.DAO.DeleteStorageItem(n.ContractID, key); err != nil { + if err := ic.DAO.DeleteStorageItem(n.ID, key); err != nil { panic(err) } return stackitem.Null{} @@ -532,7 +532,7 @@ func (n *NameService) getRecordsInternal(d dao.DAO, name string) map[RecordType] key := makeRecordKey(domain, name, 0) key = key[:len(key)-1] res := make(map[RecordType]string) - d.Seek(n.ContractID, key, func(k, v []byte) { + d.Seek(n.ID, key, func(k, v []byte) { rt := RecordType(k[len(k)-1]) var si state.StorageItem r := io.NewBinReaderFromBuf(v) diff --git a/pkg/core/native/native_neo.go b/pkg/core/native/native_neo.go index c9f8b585e..57f83d713 100644 --- a/pkg/core/native/native_neo.go +++ b/pkg/core/native/native_neo.go @@ -170,7 +170,7 @@ func (n *NEO) Initialize(ic *interop.Context) error { return err } - err = ic.DAO.PutStorageItem(n.ContractID, prefixCommittee, &state.StorageItem{Value: cvs.Bytes()}) + err = ic.DAO.PutStorageItem(n.ID, prefixCommittee, &state.StorageItem{Value: cvs.Bytes()}) if err != nil { return err } @@ -190,7 +190,7 @@ func (n *NEO) Initialize(ic *interop.Context) error { gr := &gasRecord{{Index: index, GASPerBlock: *value}} n.gasPerBlock.Store(*gr) n.gasPerBlockChanged.Store(false) - err = ic.DAO.PutStorageItem(n.ContractID, []byte{prefixVotersCount}, &state.StorageItem{Value: []byte{}}) + err = ic.DAO.PutStorageItem(n.ID, []byte{prefixVotersCount}, &state.StorageItem{Value: []byte{}}) if err != nil { return err } @@ -203,7 +203,7 @@ func (n *NEO) Initialize(ic *interop.Context) error { // called only when deploying native contracts. func (n *NEO) InitializeCache(bc blockchainer.Blockchainer, d dao.DAO) error { var committee = keysWithVotes{} - si := d.GetStorageItem(n.ContractID, prefixCommittee) + si := d.GetStorageItem(n.ID, prefixCommittee) if err := committee.DecodeBytes(si.Value); err != nil { return err } @@ -243,7 +243,7 @@ func (n *NEO) updateCommittee(ic *interop.Context) error { // We need to put in storage anyway, as it affects dumps committee := n.committee.Load().(keysWithVotes) si := &state.StorageItem{Value: committee.Bytes()} - return ic.DAO.PutStorageItem(n.ContractID, prefixCommittee, si) + return ic.DAO.PutStorageItem(n.ID, prefixCommittee, si) } _, cvs, err := n.computeCommitteeMembers(ic.Chain, ic.DAO) @@ -255,7 +255,7 @@ func (n *NEO) updateCommittee(ic *interop.Context) error { } n.votesChanged.Store(false) si := &state.StorageItem{Value: cvs.Bytes()} - return ic.DAO.PutStorageItem(n.ContractID, prefixCommittee, si) + return ic.DAO.PutStorageItem(n.ID, prefixCommittee, si) } // ShouldUpdateCommittee returns true if committee is updated at block h. @@ -311,7 +311,7 @@ func (n *NEO) PostPersist(ic *interop.Context) error { binary.BigEndian.PutUint32(key[34:], ic.Block.Index+1) si.Value = bigint.ToBytes(tmp) - if err := ic.DAO.PutStorageItem(n.ContractID, key, si); err != nil { + if err := ic.DAO.PutStorageItem(n.ID, key, si); err != nil { return err } } @@ -333,7 +333,7 @@ func (n *NEO) getGASPerVote(d dao.DAO, key []byte, index ...uint32) []big.Int { var max = make([]uint32, len(index)) var reward = make([]big.Int, len(index)) var si state.StorageItem - d.Seek(n.ContractID, key, func(k, v []byte) { + d.Seek(n.ID, key, func(k, v []byte) { if len(k) == 4 { num := binary.BigEndian.Uint32(k) for i, ind := range index { @@ -413,7 +413,7 @@ func (n *NEO) getGASPerBlock(ic *interop.Context, _ []stackitem.Item) stackitem. } func (n *NEO) getSortedGASRecordFromDAO(d dao.DAO) (gasRecord, error) { - grMap, err := d.GetStorageItemsWithPrefix(n.ContractID, []byte{prefixGASPerBlock}) + grMap, err := d.GetStorageItemsWithPrefix(n.ID, []byte{prefixGASPerBlock}) if err != nil { return gasRecord{}, fmt.Errorf("failed to get gas records from storage: %w", err) } @@ -495,16 +495,16 @@ func (n *NEO) dropCandidateIfZero(d dao.DAO, pub *keys.PublicKey, c *candidate) if c.Registered || c.Votes.Sign() != 0 { return false, nil } - if err := d.DeleteStorageItem(n.ContractID, makeValidatorKey(pub)); err != nil { + if err := d.DeleteStorageItem(n.ID, makeValidatorKey(pub)); err != nil { return true, err } var toRemove []string - d.Seek(n.ContractID, makeVoterKey(pub.Bytes()), func(k, v []byte) { + d.Seek(n.ID, makeVoterKey(pub.Bytes()), func(k, v []byte) { toRemove = append(toRemove, string(k)) }) for i := range toRemove { - if err := d.DeleteStorageItem(n.ContractID, []byte(toRemove[i])); err != nil { + if err := d.DeleteStorageItem(n.ID, []byte(toRemove[i])); err != nil { return true, err } } @@ -527,7 +527,7 @@ func makeVoterKey(pub []byte, prealloc ...[]byte) []byte { // and having voted for active committee member. func (n *NEO) CalculateBonus(d dao.DAO, acc util.Uint160, end uint32) (*big.Int, error) { key := makeAccountKey(acc) - si := d.GetStorageItem(n.ContractID, key) + si := d.GetStorageItem(n.ID, key) if si == nil { return nil, storage.ErrKeyNotFound } @@ -608,7 +608,7 @@ func (n *NEO) registerCandidate(ic *interop.Context, args []stackitem.Item) stac // RegisterCandidateInternal registers pub as a new candidate. func (n *NEO) RegisterCandidateInternal(ic *interop.Context, pub *keys.PublicKey) error { key := makeValidatorKey(pub) - si := ic.DAO.GetStorageItem(n.ContractID, key) + si := ic.DAO.GetStorageItem(n.ID, key) if si == nil { c := &candidate{Registered: true} si = &state.StorageItem{Value: c.Bytes()} @@ -617,7 +617,7 @@ func (n *NEO) RegisterCandidateInternal(ic *interop.Context, pub *keys.PublicKey c.Registered = true si.Value = c.Bytes() } - return ic.DAO.PutStorageItem(n.ContractID, key, si) + return ic.DAO.PutStorageItem(n.ID, key, si) } func (n *NEO) unregisterCandidate(ic *interop.Context, args []stackitem.Item) stackitem.Item { @@ -635,7 +635,7 @@ func (n *NEO) unregisterCandidate(ic *interop.Context, args []stackitem.Item) st // UnregisterCandidateInternal unregisters pub as a candidate. func (n *NEO) UnregisterCandidateInternal(ic *interop.Context, pub *keys.PublicKey) error { key := makeValidatorKey(pub) - si := ic.DAO.GetStorageItem(n.ContractID, key) + si := ic.DAO.GetStorageItem(n.ID, key) if si == nil { return nil } @@ -647,7 +647,7 @@ func (n *NEO) UnregisterCandidateInternal(ic *interop.Context, pub *keys.PublicK return err } si.Value = c.Bytes() - return ic.DAO.PutStorageItem(n.ContractID, key, si) + return ic.DAO.PutStorageItem(n.ID, key, si) } func (n *NEO) vote(ic *interop.Context, args []stackitem.Item) stackitem.Item { @@ -669,7 +669,7 @@ func (n *NEO) VoteInternal(ic *interop.Context, h util.Uint160, pub *keys.Public return errors.New("invalid signature") } key := makeAccountKey(h) - si := ic.DAO.GetStorageItem(n.ContractID, key) + si := ic.DAO.GetStorageItem(n.ID, key) if si == nil { return errors.New("invalid account") } @@ -697,7 +697,7 @@ func (n *NEO) VoteInternal(ic *interop.Context, h util.Uint160, pub *keys.Public return err } si.Value = acc.Bytes() - return ic.DAO.PutStorageItem(n.ContractID, key, si) + return ic.DAO.PutStorageItem(n.ID, key, si) } // ModifyAccountVotes modifies votes of the specified account by value (can be negative). @@ -706,7 +706,7 @@ func (n *NEO) ModifyAccountVotes(acc *state.NEOBalanceState, d dao.DAO, value *b n.votesChanged.Store(true) if acc.VoteTo != nil { key := makeValidatorKey(acc.VoteTo) - si := d.GetStorageItem(n.ContractID, key) + si := d.GetStorageItem(n.ID, key) if si == nil { return errors.New("invalid validator") } @@ -722,13 +722,13 @@ func (n *NEO) ModifyAccountVotes(acc *state.NEOBalanceState, d dao.DAO, value *b } n.validators.Store(keys.PublicKeys(nil)) si.Value = cd.Bytes() - return d.PutStorageItem(n.ContractID, key, si) + return d.PutStorageItem(n.ID, key, si) } return nil } func (n *NEO) getCandidates(d dao.DAO, sortByKey bool) ([]keyWithVotes, error) { - siMap, err := d.GetStorageItemsWithPrefix(n.ContractID, []byte{prefixCandidate}) + siMap, err := d.GetStorageItemsWithPrefix(n.ID, []byte{prefixCandidate}) if err != nil { return nil, err } @@ -811,14 +811,14 @@ func (n *NEO) getCommittee(ic *interop.Context, _ []stackitem.Item) stackitem.It func (n *NEO) modifyVoterTurnout(d dao.DAO, amount *big.Int) error { key := []byte{prefixVotersCount} - si := d.GetStorageItem(n.ContractID, key) + si := d.GetStorageItem(n.ID, key) if si == nil { return errors.New("voters count not found") } votersCount := bigint.FromBytes(si.Value) votersCount.Add(votersCount, amount) si.Value = bigint.ToBytes(votersCount) - return d.PutStorageItem(n.ContractID, key, si) + return d.PutStorageItem(n.ID, key, si) } // GetCommitteeMembers returns public keys of nodes in committee using cached value. @@ -848,7 +848,7 @@ func toKeysWithVotes(pubs keys.PublicKeys) keysWithVotes { // computeCommitteeMembers returns public keys of nodes in committee. func (n *NEO) computeCommitteeMembers(bc blockchainer.Blockchainer, d dao.DAO) (keys.PublicKeys, keysWithVotes, error) { key := []byte{prefixVotersCount} - si := d.GetStorageItem(n.ContractID, key) + si := d.GetStorageItem(n.ID, key) if si == nil { return nil, nil, errors.New("voters count not found") } @@ -928,5 +928,5 @@ func (n *NEO) putGASRecord(dao dao.DAO, index uint32, value *big.Int) error { Value: bigint.ToBytes(value), IsConst: false, } - return dao.PutStorageItem(n.ContractID, key, si) + return dao.PutStorageItem(n.ID, key, si) } diff --git a/pkg/core/native/native_nep17.go b/pkg/core/native/native_nep17.go index ca092bd8b..7c2a0f1c7 100644 --- a/pkg/core/native/native_nep17.go +++ b/pkg/core/native/native_nep17.go @@ -96,7 +96,7 @@ func (c *nep17TokenNative) TotalSupply(ic *interop.Context, _ []stackitem.Item) } func (c *nep17TokenNative) getTotalSupply(d dao.DAO) *big.Int { - si := d.GetStorageItem(c.ContractID, totalSupplyKey) + si := d.GetStorageItem(c.ID, totalSupplyKey) if si == nil { return big.NewInt(0) } @@ -105,7 +105,7 @@ func (c *nep17TokenNative) getTotalSupply(d dao.DAO) *big.Int { func (c *nep17TokenNative) saveTotalSupply(d dao.DAO, supply *big.Int) error { si := &state.StorageItem{Value: bigint.ToBytes(supply)} - return d.PutStorageItem(c.ContractID, totalSupplyKey, si) + return d.PutStorageItem(c.ID, totalSupplyKey, si) } func (c *nep17TokenNative) Transfer(ic *interop.Context, args []stackitem.Item) stackitem.Item { @@ -163,7 +163,7 @@ func (c *nep17TokenNative) emitTransfer(ic *interop.Context, from, to *util.Uint func (c *nep17TokenNative) updateAccBalance(ic *interop.Context, acc util.Uint160, amount *big.Int) error { key := makeAccountKey(acc) - si := ic.DAO.GetStorageItem(c.ContractID, key) + si := ic.DAO.GetStorageItem(c.ID, key) if si == nil { if amount.Sign() <= 0 { return errors.New("insufficient funds") @@ -176,9 +176,9 @@ func (c *nep17TokenNative) updateAccBalance(ic *interop.Context, acc util.Uint16 return err } if si.Value == nil { - err = ic.DAO.DeleteStorageItem(c.ContractID, key) + err = ic.DAO.DeleteStorageItem(c.ID, key) } else { - err = ic.DAO.PutStorageItem(c.ContractID, key, si) + err = ic.DAO.PutStorageItem(c.ID, key, si) } return err } @@ -225,7 +225,7 @@ func (c *nep17TokenNative) balanceOf(ic *interop.Context, args []stackitem.Item) if err != nil { panic(err) } - balance := bs.Trackers[c.ContractID].Balance + balance := bs.Trackers[c.ID].Balance return stackitem.NewBigInteger(&balance) } @@ -251,14 +251,14 @@ func (c *nep17TokenNative) addTokens(ic *interop.Context, h util.Uint160, amount } key := makeAccountKey(h) - si := ic.DAO.GetStorageItem(c.ContractID, key) + si := ic.DAO.GetStorageItem(c.ID, key) if si == nil { si = new(state.StorageItem) } if err := c.incBalance(ic, h, si, amount); err != nil { panic(err) } - if err := ic.DAO.PutStorageItem(c.ContractID, key, si); err != nil { + if err := ic.DAO.PutStorageItem(c.ID, key, si); err != nil { panic(err) } diff --git a/pkg/core/native/nonfungible.go b/pkg/core/native/nonfungible.go index dd31eeafa..afbfd7292 100644 --- a/pkg/core/native/nonfungible.go +++ b/pkg/core/native/nonfungible.go @@ -121,7 +121,7 @@ func newNonFungible(name string, id int32, symbol string, decimals byte) *nonfun // Initialize implements interop.Contract interface. func (n nonfungible) Initialize(ic *interop.Context) error { - return setIntWithKey(n.ContractID, ic.DAO, nftTotalSupplyKey, 0) + return setIntWithKey(n.ID, ic.DAO, nftTotalSupplyKey, 0) } func (n *nonfungible) symbol(_ *interop.Context, _ []stackitem.Item) stackitem.Item { @@ -137,7 +137,7 @@ func (n *nonfungible) totalSupply(ic *interop.Context, _ []stackitem.Item) stack } func (n *nonfungible) TotalSupply(d dao.DAO) *big.Int { - si := d.GetStorageItem(n.ContractID, nftTotalSupplyKey) + si := d.GetStorageItem(n.ID, nftTotalSupplyKey) if si == nil { panic(errors.New("total supply is not initialized")) } @@ -146,7 +146,7 @@ func (n *nonfungible) TotalSupply(d dao.DAO) *big.Int { func (n *nonfungible) setTotalSupply(d dao.DAO, ts *big.Int) { si := &state.StorageItem{Value: bigint.ToBytes(ts)} - err := d.PutStorageItem(n.ContractID, nftTotalSupplyKey, si) + err := d.PutStorageItem(n.ID, nftTotalSupplyKey, si) if err != nil { panic(err) } @@ -155,23 +155,23 @@ func (n *nonfungible) setTotalSupply(d dao.DAO, ts *big.Int) { func (n *nonfungible) tokenState(d dao.DAO, tokenID []byte) (nftTokenState, []byte, error) { key := n.getTokenKey(tokenID) s := n.newTokenState() - err := getSerializableFromDAO(n.ContractID, d, key, s) + err := getSerializableFromDAO(n.ID, d, key, s) return s, key, err } func (n *nonfungible) accountState(d dao.DAO, owner util.Uint160) (*state.NFTAccountState, []byte, error) { acc := new(state.NFTAccountState) keyAcc := makeNFTAccountKey(owner) - err := getSerializableFromDAO(n.ContractID, d, keyAcc, acc) + err := getSerializableFromDAO(n.ID, d, keyAcc, acc) return acc, keyAcc, err } func (n *nonfungible) putAccountState(d dao.DAO, key []byte, acc *state.NFTAccountState) { var err error if acc.Balance.Sign() == 0 { - err = d.DeleteStorageItem(n.ContractID, key) + err = d.DeleteStorageItem(n.ID, key) } else { - err = putSerializableToDAO(n.ContractID, d, key, acc) + err = putSerializableToDAO(n.ID, d, key, acc) } if err != nil { panic(err) @@ -216,7 +216,7 @@ func (n *nonfungible) BalanceOf(ic *interop.Context, args []stackitem.Item) stac func (n *nonfungible) tokens(ic *interop.Context, args []stackitem.Item) stackitem.Item { prefix := []byte{prefixNFTToken} - siMap, err := ic.DAO.GetStorageItemsWithPrefix(n.ContractID, prefix) + siMap, err := ic.DAO.GetStorageItemsWithPrefix(n.ID, prefix) if err != nil { panic(err) } @@ -248,10 +248,10 @@ func (n *nonfungible) tokensOf(ic *interop.Context, args []stackitem.Item) stack func (n *nonfungible) mint(ic *interop.Context, s nftTokenState) { key := n.getTokenKey(s.ID()) - if ic.DAO.GetStorageItem(n.ContractID, key) != nil { + if ic.DAO.GetStorageItem(n.ID, key) != nil { panic("token is already minted") } - if err := putSerializableToDAO(n.ContractID, ic.DAO, key, s); err != nil { + if err := putSerializableToDAO(n.ID, ic.DAO, key, s); err != nil { panic(err) } @@ -310,11 +310,11 @@ func (n *nonfungible) burn(ic *interop.Context, tokenID []byte) { func (n *nonfungible) burnByKey(ic *interop.Context, key []byte) { token := n.newTokenState() - err := getSerializableFromDAO(n.ContractID, ic.DAO, key, token) + err := getSerializableFromDAO(n.ID, ic.DAO, key, token) if err != nil { panic(err) } - if err := ic.DAO.DeleteStorageItem(n.ContractID, key); err != nil { + if err := ic.DAO.DeleteStorageItem(n.ID, key); err != nil { panic(err) } @@ -361,7 +361,7 @@ func (n *nonfungible) transfer(ic *interop.Context, args []stackitem.Item) stack token.Base().Owner = to n.onTransferred(token) - err = putSerializableToDAO(n.ContractID, ic.DAO, tokenKey, token) + err = putSerializableToDAO(n.ID, ic.DAO, tokenKey, token) if err != nil { panic(err) } diff --git a/pkg/core/native/notary.go b/pkg/core/native/notary.go index bcbdf6867..4062c2d4c 100644 --- a/pkg/core/native/notary.go +++ b/pkg/core/native/notary.go @@ -108,7 +108,7 @@ func (n *Notary) Metadata() *interop.ContractMD { // Initialize initializes Notary native contract and implements Contract interface. func (n *Notary) Initialize(ic *interop.Context) error { - err := setIntWithKey(n.ContractID, ic.DAO, maxNotValidBeforeDeltaKey, defaultMaxNotValidBeforeDelta) + err := setIntWithKey(n.ID, ic.DAO, maxNotValidBeforeDeltaKey, defaultMaxNotValidBeforeDelta) if err != nil { return err } @@ -171,7 +171,7 @@ func (n *Notary) PostPersist(ic *interop.Context) error { return nil } - n.maxNotValidBeforeDelta = uint32(getIntWithKey(n.ContractID, ic.DAO, maxNotValidBeforeDeltaKey)) + n.maxNotValidBeforeDelta = uint32(getIntWithKey(n.ID, ic.DAO, maxNotValidBeforeDeltaKey)) n.isValid = true return nil } @@ -384,7 +384,7 @@ func (n *Notary) GetMaxNotValidBeforeDelta(dao dao.DAO) uint32 { if n.isValid { return n.maxNotValidBeforeDelta } - return uint32(getIntWithKey(n.ContractID, dao, maxNotValidBeforeDeltaKey)) + return uint32(getIntWithKey(n.ID, dao, maxNotValidBeforeDeltaKey)) } // setMaxNotValidBeforeDelta is Notary contract method and sets the maximum NotValidBefore delta. @@ -398,7 +398,7 @@ func (n *Notary) setMaxNotValidBeforeDelta(ic *interop.Context, args []stackitem } n.lock.Lock() defer n.lock.Unlock() - err := setIntWithKey(n.ContractID, ic.DAO, maxNotValidBeforeDeltaKey, int64(value)) + err := setIntWithKey(n.ID, ic.DAO, maxNotValidBeforeDeltaKey, int64(value)) if err != nil { panic(fmt.Errorf("failed to put value into the storage: %w", err)) } @@ -411,7 +411,7 @@ func (n *Notary) setMaxNotValidBeforeDelta(ic *interop.Context, args []stackitem func (n *Notary) GetDepositFor(dao dao.DAO, acc util.Uint160) *state.Deposit { key := append([]byte{prefixDeposit}, acc.BytesBE()...) deposit := new(state.Deposit) - err := getSerializableFromDAO(n.ContractID, dao, key, deposit) + err := getSerializableFromDAO(n.ID, dao, key, deposit) if err == nil { return deposit } @@ -424,13 +424,13 @@ func (n *Notary) GetDepositFor(dao dao.DAO, acc util.Uint160) *state.Deposit { // putDepositFor puts deposit on the balance of the specified account in the storage. func (n *Notary) putDepositFor(dao dao.DAO, deposit *state.Deposit, acc util.Uint160) error { key := append([]byte{prefixDeposit}, acc.BytesBE()...) - return putSerializableToDAO(n.ContractID, dao, key, deposit) + return putSerializableToDAO(n.ID, dao, key, deposit) } // removeDepositFor removes deposit from the storage. func (n *Notary) removeDepositFor(dao dao.DAO, acc util.Uint160) error { key := append([]byte{prefixDeposit}, acc.BytesBE()...) - return dao.DeleteStorageItem(n.ContractID, key) + return dao.DeleteStorageItem(n.ID, key) } // calculateNotaryReward calculates the reward for a single notary node based on FEE's count and Notary nodes count. diff --git a/pkg/core/native/oracle.go b/pkg/core/native/oracle.go index 582a145d7..da72ab1c6 100644 --- a/pkg/core/native/oracle.go +++ b/pkg/core/native/oracle.go @@ -145,7 +145,7 @@ func (o *Oracle) PostPersist(ic *interop.Context) error { if err := o.getSerializableFromDAO(ic.DAO, reqKey, req); err != nil { continue } - if err := ic.DAO.DeleteStorageItem(o.ContractID, reqKey); err != nil { + if err := ic.DAO.DeleteStorageItem(o.ID, reqKey); err != nil { return err } if orc != nil { @@ -163,10 +163,10 @@ func (o *Oracle) PostPersist(ic *interop.Context) error { var err error if len(*idList) == 0 { - err = ic.DAO.DeleteStorageItem(o.ContractID, idKey) + err = ic.DAO.DeleteStorageItem(o.ID, idKey) } else { si := &state.StorageItem{Value: idList.Bytes()} - err = ic.DAO.PutStorageItem(o.ContractID, idKey, si) + err = ic.DAO.PutStorageItem(o.ID, idKey, si) } if err != nil { return err @@ -202,7 +202,7 @@ func (o *Oracle) Metadata() *interop.ContractMD { // Initialize initializes Oracle contract. func (o *Oracle) Initialize(ic *interop.Context) error { - return setIntWithKey(o.ContractID, ic.DAO, prefixRequestID, 0) + return setIntWithKey(o.ID, ic.DAO, prefixRequestID, 0) } func getResponse(tx *transaction.Transaction) *transaction.OracleResponse { @@ -301,12 +301,12 @@ func (o *Oracle) RequestInternal(ic *interop.Context, url string, filter *string } callingHash := ic.VM.GetCallingScriptHash() o.GAS.mint(ic, o.Hash, gas, false) - si := ic.DAO.GetStorageItem(o.ContractID, prefixRequestID) + si := ic.DAO.GetStorageItem(o.ID, prefixRequestID) itemID := bigint.FromBytes(si.Value) id := itemID.Uint64() itemID.Add(itemID, intOne) si.Value = bigint.ToPreallocatedBytes(itemID, si.Value) - if err := ic.DAO.PutStorageItem(o.ContractID, prefixRequestID, si); err != nil { + if err := ic.DAO.PutStorageItem(o.ID, prefixRequestID, si); err != nil { return err } @@ -358,7 +358,7 @@ func (o *Oracle) RequestInternal(ic *interop.Context, url string, filter *string func (o *Oracle) PutRequestInternal(id uint64, req *state.OracleRequest, d dao.DAO) error { reqItem := &state.StorageItem{Value: req.Bytes()} reqKey := makeRequestKey(id) - if err := d.PutStorageItem(o.ContractID, reqKey, reqItem); err != nil { + if err := d.PutStorageItem(o.ID, reqKey, reqItem); err != nil { return err } o.newRequests[id] = req @@ -374,7 +374,7 @@ func (o *Oracle) PutRequestInternal(id uint64, req *state.OracleRequest, d dao.D } *lst = append(*lst, id) si := &state.StorageItem{Value: lst.Bytes()} - return d.PutStorageItem(o.ContractID, key, si) + return d.PutStorageItem(o.ID, key, si) } // GetScriptHash returns script hash or oracle nodes. @@ -419,7 +419,7 @@ func (o *Oracle) getOriginalTxID(d dao.DAO, tx *transaction.Transaction) util.Ui // getRequests returns all requests which have not been finished yet. func (o *Oracle) getRequests(d dao.DAO) (map[uint64]*state.OracleRequest, error) { - m, err := d.GetStorageItemsWithPrefix(o.ContractID, prefixRequest) + m, err := d.GetStorageItemsWithPrefix(o.ID, prefixRequest) if err != nil { return nil, err } @@ -452,7 +452,7 @@ func makeIDListKey(url string) []byte { } func (o *Oracle) getSerializableFromDAO(d dao.DAO, key []byte, item io.Serializable) error { - return getSerializableFromDAO(o.ContractID, d, key, item) + return getSerializableFromDAO(o.ID, d, key, item) } // updateCache updates cached Oracle values if they've been changed @@ -466,7 +466,7 @@ func (o *Oracle) updateCache(d dao.DAO) error { o.newRequests = make(map[uint64]*state.OracleRequest) for id := range reqs { key := makeRequestKey(id) - if si := d.GetStorageItem(o.ContractID, key); si == nil { // tx has failed + if si := d.GetStorageItem(o.ID, key); si == nil { // tx has failed delete(reqs, id) } } diff --git a/pkg/core/native/policy.go b/pkg/core/native/policy.go index 369bfd752..ac09d5029 100644 --- a/pkg/core/native/policy.go +++ b/pkg/core/native/policy.go @@ -166,22 +166,22 @@ func (p *Policy) Metadata() *interop.ContractMD { // Initialize initializes Policy native contract and implements Contract interface. func (p *Policy) Initialize(ic *interop.Context) error { - if err := setIntWithKey(p.ContractID, ic.DAO, maxTransactionsPerBlockKey, defaultMaxTransactionsPerBlock); err != nil { + if err := setIntWithKey(p.ID, ic.DAO, maxTransactionsPerBlockKey, defaultMaxTransactionsPerBlock); err != nil { return err } - if err := setIntWithKey(p.ContractID, ic.DAO, feePerByteKey, defaultFeePerByte); err != nil { + if err := setIntWithKey(p.ID, ic.DAO, feePerByteKey, defaultFeePerByte); err != nil { return err } - if err := setIntWithKey(p.ContractID, ic.DAO, maxBlockSizeKey, defaultMaxBlockSize); err != nil { + if err := setIntWithKey(p.ID, ic.DAO, maxBlockSizeKey, defaultMaxBlockSize); err != nil { return err } - if err := setIntWithKey(p.ContractID, ic.DAO, maxBlockSystemFeeKey, defaultMaxBlockSystemFee); err != nil { + if err := setIntWithKey(p.ID, ic.DAO, maxBlockSystemFeeKey, defaultMaxBlockSystemFee); err != nil { return err } - if err := setIntWithKey(p.ContractID, ic.DAO, execFeeFactorKey, defaultExecFeeFactor); err != nil { + if err := setIntWithKey(p.ID, ic.DAO, execFeeFactorKey, defaultExecFeeFactor); err != nil { return err } - if err := setIntWithKey(p.ContractID, ic.DAO, storagePriceKey, DefaultStoragePrice); err != nil { + if err := setIntWithKey(p.ID, ic.DAO, storagePriceKey, DefaultStoragePrice); err != nil { return err } @@ -211,16 +211,16 @@ func (p *Policy) PostPersist(ic *interop.Context) error { return nil } - p.maxTransactionsPerBlock = uint32(getIntWithKey(p.ContractID, ic.DAO, maxTransactionsPerBlockKey)) - p.maxBlockSize = uint32(getIntWithKey(p.ContractID, ic.DAO, maxBlockSizeKey)) - p.execFeeFactor = uint32(getIntWithKey(p.ContractID, ic.DAO, execFeeFactorKey)) - p.feePerByte = getIntWithKey(p.ContractID, ic.DAO, feePerByteKey) - p.maxBlockSystemFee = getIntWithKey(p.ContractID, ic.DAO, maxBlockSystemFeeKey) + p.maxTransactionsPerBlock = uint32(getIntWithKey(p.ID, ic.DAO, maxTransactionsPerBlockKey)) + p.maxBlockSize = uint32(getIntWithKey(p.ID, ic.DAO, maxBlockSizeKey)) + p.execFeeFactor = uint32(getIntWithKey(p.ID, ic.DAO, execFeeFactorKey)) + p.feePerByte = getIntWithKey(p.ID, ic.DAO, feePerByteKey) + p.maxBlockSystemFee = getIntWithKey(p.ID, ic.DAO, maxBlockSystemFeeKey) p.maxVerificationGas = defaultMaxVerificationGas - p.storagePrice = uint32(getIntWithKey(p.ContractID, ic.DAO, storagePriceKey)) + p.storagePrice = uint32(getIntWithKey(p.ID, ic.DAO, storagePriceKey)) p.blockedAccounts = make([]util.Uint160, 0) - siMap, err := ic.DAO.GetStorageItemsWithPrefix(p.ContractID, []byte{blockedAccountPrefix}) + siMap, err := ic.DAO.GetStorageItemsWithPrefix(p.ID, []byte{blockedAccountPrefix}) if err != nil { return fmt.Errorf("failed to get blocked accounts from storage: %w", err) } @@ -253,7 +253,7 @@ func (p *Policy) GetMaxTransactionsPerBlockInternal(dao dao.DAO) uint32 { if p.isValid { return p.maxTransactionsPerBlock } - return uint32(getIntWithKey(p.ContractID, dao, maxTransactionsPerBlockKey)) + return uint32(getIntWithKey(p.ID, dao, maxTransactionsPerBlockKey)) } // getMaxBlockSize is Policy contract method and returns maximum block size. @@ -268,7 +268,7 @@ func (p *Policy) GetMaxBlockSizeInternal(dao dao.DAO) uint32 { if p.isValid { return p.maxBlockSize } - return uint32(getIntWithKey(p.ContractID, dao, maxBlockSizeKey)) + return uint32(getIntWithKey(p.ID, dao, maxBlockSizeKey)) } // getFeePerByte is Policy contract method and returns required transaction's fee @@ -284,7 +284,7 @@ func (p *Policy) GetFeePerByteInternal(dao dao.DAO) int64 { if p.isValid { return p.feePerByte } - return getIntWithKey(p.ContractID, dao, feePerByteKey) + return getIntWithKey(p.ID, dao, feePerByteKey) } // GetMaxVerificationGas returns maximum gas allowed to be burned during verificaion. @@ -308,7 +308,7 @@ func (p *Policy) GetMaxBlockSystemFeeInternal(dao dao.DAO) int64 { if p.isValid { return p.maxBlockSystemFee } - return getIntWithKey(p.ContractID, dao, maxBlockSystemFeeKey) + return getIntWithKey(p.ID, dao, maxBlockSystemFeeKey) } func (p *Policy) getExecFeeFactor(ic *interop.Context, _ []stackitem.Item) stackitem.Item { @@ -322,7 +322,7 @@ func (p *Policy) GetExecFeeFactorInternal(d dao.DAO) int64 { if p.isValid { return int64(p.execFeeFactor) } - return getIntWithKey(p.ContractID, d, execFeeFactorKey) + return getIntWithKey(p.ID, d, execFeeFactorKey) } func (p *Policy) setExecFeeFactor(ic *interop.Context, args []stackitem.Item) stackitem.Item { @@ -335,7 +335,7 @@ func (p *Policy) setExecFeeFactor(ic *interop.Context, args []stackitem.Item) st } p.lock.Lock() defer p.lock.Unlock() - err := setIntWithKey(p.ContractID, ic.DAO, execFeeFactorKey, int64(value)) + err := setIntWithKey(p.ID, ic.DAO, execFeeFactorKey, int64(value)) if err != nil { panic(err) } @@ -364,7 +364,7 @@ func (p *Policy) IsBlockedInternal(dao dao.DAO, hash util.Uint160) bool { return false } key := append([]byte{blockedAccountPrefix}, hash.BytesBE()...) - return dao.GetStorageItem(p.ContractID, key) != nil + return dao.GetStorageItem(p.ID, key) != nil } func (p *Policy) getStoragePrice(ic *interop.Context, _ []stackitem.Item) stackitem.Item { @@ -378,7 +378,7 @@ func (p *Policy) GetStoragePriceInternal(d dao.DAO) int64 { if p.isValid { return int64(p.storagePrice) } - return getIntWithKey(p.ContractID, d, storagePriceKey) + return getIntWithKey(p.ID, d, storagePriceKey) } func (p *Policy) setStoragePrice(ic *interop.Context, args []stackitem.Item) stackitem.Item { @@ -391,7 +391,7 @@ func (p *Policy) setStoragePrice(ic *interop.Context, args []stackitem.Item) sta } p.lock.Lock() defer p.lock.Unlock() - err := setIntWithKey(p.ContractID, ic.DAO, storagePriceKey, int64(value)) + err := setIntWithKey(p.ID, ic.DAO, storagePriceKey, int64(value)) if err != nil { panic(err) } @@ -411,7 +411,7 @@ func (p *Policy) setMaxTransactionsPerBlock(ic *interop.Context, args []stackite } p.lock.Lock() defer p.lock.Unlock() - err := setIntWithKey(p.ContractID, ic.DAO, maxTransactionsPerBlockKey, int64(value)) + err := setIntWithKey(p.ID, ic.DAO, maxTransactionsPerBlockKey, int64(value)) if err != nil { panic(err) } @@ -430,7 +430,7 @@ func (p *Policy) setMaxBlockSize(ic *interop.Context, args []stackitem.Item) sta } p.lock.Lock() defer p.lock.Unlock() - err := setIntWithKey(p.ContractID, ic.DAO, maxBlockSizeKey, int64(value)) + err := setIntWithKey(p.ID, ic.DAO, maxBlockSizeKey, int64(value)) if err != nil { panic(err) } @@ -449,7 +449,7 @@ func (p *Policy) setFeePerByte(ic *interop.Context, args []stackitem.Item) stack } p.lock.Lock() defer p.lock.Unlock() - err := setIntWithKey(p.ContractID, ic.DAO, feePerByteKey, value) + err := setIntWithKey(p.ID, ic.DAO, feePerByteKey, value) if err != nil { panic(err) } @@ -468,7 +468,7 @@ func (p *Policy) setMaxBlockSystemFee(ic *interop.Context, args []stackitem.Item } p.lock.Lock() defer p.lock.Unlock() - err := setIntWithKey(p.ContractID, ic.DAO, maxBlockSystemFeeKey, value) + err := setIntWithKey(p.ID, ic.DAO, maxBlockSystemFeeKey, value) if err != nil { panic(err) } @@ -489,7 +489,7 @@ func (p *Policy) blockAccount(ic *interop.Context, args []stackitem.Item) stacki key := append([]byte{blockedAccountPrefix}, hash.BytesBE()...) p.lock.Lock() defer p.lock.Unlock() - err := ic.DAO.PutStorageItem(p.ContractID, key, &state.StorageItem{ + err := ic.DAO.PutStorageItem(p.ID, key, &state.StorageItem{ Value: []byte{}, }) if err != nil { @@ -512,7 +512,7 @@ func (p *Policy) unblockAccount(ic *interop.Context, args []stackitem.Item) stac key := append([]byte{blockedAccountPrefix}, hash.BytesBE()...) p.lock.Lock() defer p.lock.Unlock() - err := ic.DAO.DeleteStorageItem(p.ContractID, key) + err := ic.DAO.DeleteStorageItem(p.ID, key) if err != nil { panic(err) } diff --git a/pkg/core/native_contract_test.go b/pkg/core/native_contract_test.go index 4aeb62d3f..5a5e85493 100644 --- a/pkg/core/native_contract_test.go +++ b/pkg/core/native_contract_test.go @@ -240,7 +240,7 @@ func TestNativeContract_InvokeInternal(t *testing.T) { v.Estack().PushVal(14) v.Estack().PushVal(28) v.Estack().PushVal("sum") - v.Estack().PushVal(tn.Metadata().ContractID) + v.Estack().PushVal(tn.Metadata().ID) require.NoError(t, native.Call(ic)) From 02ca3d3dfd0d882296f896dfd6353eadfa94402e Mon Sep 17 00:00:00 2001 From: Evgeniy Stratonikov Date: Tue, 9 Feb 2021 12:29:41 +0300 Subject: [PATCH 4/5] interop: reuse `state.Native` in `ContractMD` --- pkg/core/blockchain.go | 10 +++------- pkg/core/interop/context.go | 12 +++++------- pkg/core/native/management.go | 7 +------ 3 files changed, 9 insertions(+), 20 deletions(-) diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go index 7fa8478a5..4e9ef7e16 100644 --- a/pkg/core/blockchain.go +++ b/pkg/core/blockchain.go @@ -1245,13 +1245,9 @@ func (bc *Blockchain) GetNativeContractScriptHash(name string) (util.Uint160, er // GetNatives returns list of native contracts. func (bc *Blockchain) GetNatives() []state.NativeContract { - res := make([]state.NativeContract, len(bc.contracts.Contracts)) - for i, c := range bc.contracts.Contracts { - md := c.Metadata() - res[i].ID = md.ID - res[i].Hash = md.Hash - res[i].Manifest = md.Manifest - res[i].NEF = md.NEF + res := make([]state.NativeContract, 0, len(bc.contracts.Contracts)) + for _, c := range bc.contracts.Contracts { + res = append(res, c.Metadata().NativeContract) } return res } diff --git a/pkg/core/interop/context.go b/pkg/core/interop/context.go index c10d31933..8ce2cf65b 100644 --- a/pkg/core/interop/context.go +++ b/pkg/core/interop/context.go @@ -99,12 +99,9 @@ type Contract interface { // ContractMD represents native contract instance. type ContractMD struct { - Manifest manifest.Manifest - Name string - ID int32 - NEF nef.File - Hash util.Uint160 - Methods map[MethodAndArgCount]MethodAndPrice + state.NativeContract + Name string + Methods map[MethodAndArgCount]MethodAndPrice } // MethodAndArgCount represents method's signature. @@ -117,10 +114,11 @@ type MethodAndArgCount struct { func NewContractMD(name string, id int32) *ContractMD { c := &ContractMD{ Name: name, - ID: id, Methods: make(map[MethodAndArgCount]MethodAndPrice), } + c.ID = id + // NEF is now stored in contract state and affects state dump. // Therefore values are taken from C# node. c.NEF.Header.Compiler = "neo-core-v3.0" diff --git a/pkg/core/native/management.go b/pkg/core/native/management.go index 8145c8405..8b7e534a1 100644 --- a/pkg/core/native/management.go +++ b/pkg/core/native/management.go @@ -453,12 +453,7 @@ func (m *Management) OnPersist(ic *interop.Context) error { md := native.Metadata() cs := &state.Contract{ - ContractBase: state.ContractBase{ - ID: md.ID, - Hash: md.Hash, - NEF: md.NEF, - Manifest: md.Manifest, - }, + ContractBase: md.ContractBase, } err := m.PutContractState(ic.DAO, cs) if err != nil { From 4f1bea0bcb18f301c7108755dc89c4b0a2c7cae3 Mon Sep 17 00:00:00 2001 From: Evgeniy Stratonikov Date: Thu, 11 Feb 2021 12:37:03 +0300 Subject: [PATCH 5/5] rpc/client: implement `GetNativeContracts` --- pkg/rpc/client/rpc.go | 12 ++++++++++++ pkg/rpc/server/client_test.go | 14 ++++++++++++++ 2 files changed, 26 insertions(+) diff --git a/pkg/rpc/client/rpc.go b/pkg/rpc/client/rpc.go index 07da05f13..7466be043 100644 --- a/pkg/rpc/client/rpc.go +++ b/pkg/rpc/client/rpc.go @@ -240,6 +240,18 @@ func (c *Client) getContractState(param interface{}) (*state.Contract, error) { return resp, nil } +// GetNativeContracts queries information about native contracts. +func (c *Client) GetNativeContracts() ([]state.NativeContract, error) { + var ( + params = request.NewRawParams() + resp []state.NativeContract + ) + if err := c.performRequest("getnativecontracts", params, &resp); err != nil { + return resp, err + } + return resp, nil +} + // GetNEP17Balances is a wrapper for getnep17balances RPC. func (c *Client) GetNEP17Balances(address util.Uint160) (*result.NEP17Balances, error) { params := request.NewRawParams(address.StringLE()) diff --git a/pkg/rpc/server/client_test.go b/pkg/rpc/server/client_test.go index ddc2b1c1d..c99bdfe5c 100644 --- a/pkg/rpc/server/client_test.go +++ b/pkg/rpc/server/client_test.go @@ -322,3 +322,17 @@ func TestInvokeVerify(t *testing.T) { require.False(t, res.Stack[0].Value().(bool)) }) } + +func TestClient_GetNativeContracts(t *testing.T) { + chain, rpcSrv, httpSrv := initServerWithInMemoryChain(t) + defer chain.Close() + defer rpcSrv.Shutdown() + + c, err := client.New(context.Background(), httpSrv.URL, client.Options{}) + require.NoError(t, err) + require.NoError(t, c.Init()) + + cs, err := c.GetNativeContracts() + require.NoError(t, err) + require.Equal(t, chain.GetNatives(), cs) +}