From 588f3fbbd3dfb82cf49c7f7976cb28ba78b063cf Mon Sep 17 00:00:00 2001 From: Roman Khimov Date: Sun, 18 Jul 2021 12:39:31 +0300 Subject: [PATCH] state: drop State from NEOBalance and NEP17Balance We're in the `state` package already. --- cli/wallet/validator.go | 2 +- pkg/core/native/native_gas.go | 4 ++-- pkg/core/native/native_neo.go | 12 +++++----- pkg/core/state/native_state.go | 42 +++++++++++++++++----------------- 4 files changed, 30 insertions(+), 30 deletions(-) diff --git a/cli/wallet/validator.go b/cli/wallet/validator.go index 468e4a259..cee1ffaf4 100644 --- a/cli/wallet/validator.go +++ b/cli/wallet/validator.go @@ -252,7 +252,7 @@ func getAccountState(ctx *cli.Context) error { if len(res.Stack) == 0 { return cli.NewExitError("result stack is empty", 1) } - st := new(state.NEOBalanceState) + st := new(state.NEOBalance) err = st.FromStackItem(res.Stack[0]) if err != nil { return cli.NewExitError(fmt.Errorf("failed to convert account state from stackitem: %w", err), 1) diff --git a/pkg/core/native/native_gas.go b/pkg/core/native/native_gas.go index f0e0bed15..7167706d1 100644 --- a/pkg/core/native/native_gas.go +++ b/pkg/core/native/native_gas.go @@ -53,7 +53,7 @@ func newGAS() *GAS { } func (g *GAS) increaseBalance(_ *interop.Context, _ util.Uint160, si *state.StorageItem, amount *big.Int) error { - acc, err := state.NEP17BalanceStateFromBytes(*si) + acc, err := state.NEP17BalanceFromBytes(*si) if err != nil { return err } @@ -72,7 +72,7 @@ func (g *GAS) increaseBalance(_ *interop.Context, _ util.Uint160, si *state.Stor } func (g *GAS) balanceFromBytes(si *state.StorageItem) (*big.Int, error) { - acc, err := state.NEP17BalanceStateFromBytes(*si) + acc, err := state.NEP17BalanceFromBytes(*si) if err != nil { return nil, err } diff --git a/pkg/core/native/native_neo.go b/pkg/core/native/native_neo.go index 3726d9063..6f5fb1e9e 100644 --- a/pkg/core/native/native_neo.go +++ b/pkg/core/native/native_neo.go @@ -392,7 +392,7 @@ func (n *NEO) getGASPerVote(d dao.DAO, key []byte, index ...uint32) []big.Int { } func (n *NEO) increaseBalance(ic *interop.Context, h util.Uint160, si *state.StorageItem, amount *big.Int) error { - acc, err := state.NEOBalanceStateFromBytes(*si) + acc, err := state.NEOBalanceFromBytes(*si) if err != nil { return err } @@ -424,14 +424,14 @@ func (n *NEO) increaseBalance(ic *interop.Context, h util.Uint160, si *state.Sto } func (n *NEO) balanceFromBytes(si *state.StorageItem) (*big.Int, error) { - acc, err := state.NEOBalanceStateFromBytes(*si) + acc, err := state.NEOBalanceFromBytes(*si) if err != nil { return nil, err } return &acc.Balance, err } -func (n *NEO) distributeGas(ic *interop.Context, h util.Uint160, acc *state.NEOBalanceState) error { +func (n *NEO) distributeGas(ic *interop.Context, h util.Uint160, acc *state.NEOBalance) error { if ic.Block == nil || ic.Block.Index == 0 { return nil } @@ -609,7 +609,7 @@ func (n *NEO) CalculateBonus(d dao.DAO, acc util.Uint160, end uint32) (*big.Int, if si == nil { return nil, storage.ErrKeyNotFound } - st, err := state.NEOBalanceStateFromBytes(si) + st, err := state.NEOBalanceFromBytes(si) if err != nil { return nil, err } @@ -752,7 +752,7 @@ func (n *NEO) VoteInternal(ic *interop.Context, h util.Uint160, pub *keys.Public if si == nil { return errors.New("invalid account") } - acc, err := state.NEOBalanceStateFromBytes(si) + acc, err := state.NEOBalanceFromBytes(si) if err != nil { return err } @@ -802,7 +802,7 @@ func (n *NEO) VoteInternal(ic *interop.Context, h util.Uint160, pub *keys.Public // ModifyAccountVotes modifies votes of the specified account by value (can be negative). // typ specifies if this modify is occurring during transfer or vote (with old or new validator). -func (n *NEO) ModifyAccountVotes(acc *state.NEOBalanceState, d dao.DAO, value *big.Int, isNewVote bool) error { +func (n *NEO) ModifyAccountVotes(acc *state.NEOBalance, d dao.DAO, value *big.Int, isNewVote bool) error { n.votesChanged.Store(true) if acc.VoteTo != nil { key := makeValidatorKey(acc.VoteTo) diff --git a/pkg/core/state/native_state.go b/pkg/core/state/native_state.go index a4f652e3f..44e1adb50 100644 --- a/pkg/core/state/native_state.go +++ b/pkg/core/state/native_state.go @@ -10,21 +10,21 @@ import ( "github.com/nspcc-dev/neo-go/pkg/vm/stackitem" ) -// NEP17BalanceState represents balance state of a NEP17-token. -type NEP17BalanceState struct { +// NEP17Balance represents balance state of a NEP17-token. +type NEP17Balance struct { Balance big.Int } -// NEOBalanceState represents balance state of a NEO-token. -type NEOBalanceState struct { - NEP17BalanceState +// NEOBalance represents balance state of a NEO-token. +type NEOBalance struct { + NEP17Balance BalanceHeight uint32 VoteTo *keys.PublicKey } -// NEP17BalanceStateFromBytes converts serialized NEP17BalanceState to structure. -func NEP17BalanceStateFromBytes(b []byte) (*NEP17BalanceState, error) { - balance := new(NEP17BalanceState) +// NEP17BalanceFromBytes converts serialized NEP17Balance to structure. +func NEP17BalanceFromBytes(b []byte) (*NEP17Balance, error) { + balance := new(NEP17Balance) err := balanceFromBytes(b, balance) if err != nil { return nil, err @@ -32,8 +32,8 @@ func NEP17BalanceStateFromBytes(b []byte) (*NEP17BalanceState, error) { return balance, nil } -// Bytes returns serialized NEP17BalanceState. -func (s *NEP17BalanceState) Bytes() []byte { +// Bytes returns serialized NEP17Balance. +func (s *NEP17Balance) Bytes() []byte { return balanceToBytes(s) } @@ -53,12 +53,12 @@ func balanceToBytes(item stackitem.Convertible) []byte { } // ToStackItem implements stackitem.Convertible. It never returns an error. -func (s *NEP17BalanceState) ToStackItem() (stackitem.Item, error) { +func (s *NEP17Balance) ToStackItem() (stackitem.Item, error) { return stackitem.NewStruct([]stackitem.Item{stackitem.NewBigInteger(&s.Balance)}), nil } // FromStackItem implements stackitem.Convertible. -func (s *NEP17BalanceState) FromStackItem(item stackitem.Item) error { +func (s *NEP17Balance) FromStackItem(item stackitem.Item) error { items, ok := item.Value().([]stackitem.Item) if !ok { return errors.New("not a struct") @@ -74,9 +74,9 @@ func (s *NEP17BalanceState) FromStackItem(item stackitem.Item) error { return nil } -// NEOBalanceStateFromBytes converts serialized NEOBalanceState to structure. -func NEOBalanceStateFromBytes(b []byte) (*NEOBalanceState, error) { - balance := new(NEOBalanceState) +// NEOBalanceFromBytes converts serialized NEOBalance to structure. +func NEOBalanceFromBytes(b []byte) (*NEOBalance, error) { + balance := new(NEOBalance) err := balanceFromBytes(b, balance) if err != nil { return nil, err @@ -84,14 +84,14 @@ func NEOBalanceStateFromBytes(b []byte) (*NEOBalanceState, error) { return balance, nil } -// Bytes returns serialized NEOBalanceState. -func (s *NEOBalanceState) Bytes() []byte { +// Bytes returns serialized NEOBalance. +func (s *NEOBalance) Bytes() []byte { return balanceToBytes(s) } // ToStackItem implements stackitem.Convertible interface. It never returns an error. -func (s *NEOBalanceState) ToStackItem() (stackitem.Item, error) { - resItem, _ := s.NEP17BalanceState.ToStackItem() +func (s *NEOBalance) ToStackItem() (stackitem.Item, error) { + resItem, _ := s.NEP17Balance.ToStackItem() result := resItem.(*stackitem.Struct) result.Append(stackitem.NewBigInteger(big.NewInt(int64(s.BalanceHeight)))) if s.VoteTo != nil { @@ -102,8 +102,8 @@ func (s *NEOBalanceState) ToStackItem() (stackitem.Item, error) { return result, nil } -// FromStackItem converts stackitem.Item to NEOBalanceState. -func (s *NEOBalanceState) FromStackItem(item stackitem.Item) error { +// FromStackItem converts stackitem.Item to NEOBalance. +func (s *NEOBalance) FromStackItem(item stackitem.Item) error { structItem, ok := item.Value().([]stackitem.Item) if !ok || len(structItem) < 3 { return errors.New("invalid stackitem length")