2021-01-29 14:33:24 +00:00
|
|
|
package stateroot
|
|
|
|
|
|
|
|
import (
|
2021-02-01 16:00:07 +00:00
|
|
|
"encoding/binary"
|
|
|
|
"errors"
|
2021-01-29 14:33:24 +00:00
|
|
|
"fmt"
|
2021-02-01 16:00:07 +00:00
|
|
|
"sync"
|
2021-01-29 14:33:24 +00:00
|
|
|
|
2021-03-25 08:53:25 +00:00
|
|
|
"github.com/nspcc-dev/neo-go/pkg/config/netmode"
|
2021-01-29 14:33:24 +00:00
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/blockchainer"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/mpt"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/state"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/storage"
|
2021-02-01 16:00:07 +00:00
|
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
2021-01-29 14:33:24 +00:00
|
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
2021-08-17 15:16:10 +00:00
|
|
|
"github.com/nspcc-dev/neo-go/pkg/util/slice"
|
2021-01-29 14:33:24 +00:00
|
|
|
"go.uber.org/atomic"
|
|
|
|
"go.uber.org/zap"
|
|
|
|
)
|
|
|
|
|
|
|
|
type (
|
|
|
|
// Module represents module for local processing of state roots.
|
|
|
|
Module struct {
|
2021-03-25 08:53:25 +00:00
|
|
|
Store *storage.MemCachedStore
|
|
|
|
network netmode.Magic
|
|
|
|
mpt *mpt.Trie
|
|
|
|
bc blockchainer.Blockchainer
|
|
|
|
log *zap.Logger
|
2021-01-29 14:33:24 +00:00
|
|
|
|
2021-02-01 16:00:07 +00:00
|
|
|
currentLocal atomic.Value
|
2021-01-29 14:33:24 +00:00
|
|
|
localHeight atomic.Uint32
|
|
|
|
validatedHeight atomic.Uint32
|
2021-02-01 16:00:07 +00:00
|
|
|
|
|
|
|
mtx sync.RWMutex
|
|
|
|
keys []keyCache
|
2021-02-02 09:34:27 +00:00
|
|
|
|
2021-03-03 09:37:06 +00:00
|
|
|
updateValidatorsCb func(height uint32, publicKeys keys.PublicKeys)
|
2021-02-01 16:00:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
keyCache struct {
|
|
|
|
height uint32
|
|
|
|
validatorsKeys keys.PublicKeys
|
|
|
|
validatorsHash util.Uint160
|
|
|
|
validatorsScript []byte
|
2021-01-29 14:33:24 +00:00
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
// NewModule returns new instance of stateroot module.
|
|
|
|
func NewModule(bc blockchainer.Blockchainer, log *zap.Logger, s *storage.MemCachedStore) *Module {
|
|
|
|
return &Module{
|
2021-03-25 08:53:25 +00:00
|
|
|
network: bc.GetConfig().Magic,
|
|
|
|
bc: bc,
|
|
|
|
log: log,
|
|
|
|
Store: s,
|
2021-01-29 14:33:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetStateProof returns proof of having key in the MPT with the specified root.
|
|
|
|
func (s *Module) GetStateProof(root util.Uint256, key []byte) ([][]byte, error) {
|
|
|
|
tr := mpt.NewTrie(mpt.NewHashNode(root), false, storage.NewMemCachedStore(s.Store))
|
|
|
|
return tr.GetProof(key)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetStateRoot returns state root for a given height.
|
|
|
|
func (s *Module) GetStateRoot(height uint32) (*state.MPTRoot, error) {
|
|
|
|
return s.getStateRoot(makeStateRootKey(height))
|
|
|
|
}
|
|
|
|
|
|
|
|
// CurrentLocalStateRoot returns hash of the local state root.
|
|
|
|
func (s *Module) CurrentLocalStateRoot() util.Uint256 {
|
|
|
|
return s.currentLocal.Load().(util.Uint256)
|
|
|
|
}
|
|
|
|
|
2021-06-29 15:28:44 +00:00
|
|
|
// CurrentLocalHeight returns height of the local state root.
|
|
|
|
func (s *Module) CurrentLocalHeight() uint32 {
|
|
|
|
return s.localHeight.Load()
|
|
|
|
}
|
|
|
|
|
2021-02-01 16:00:07 +00:00
|
|
|
// CurrentValidatedHeight returns current state root validated height.
|
|
|
|
func (s *Module) CurrentValidatedHeight() uint32 {
|
|
|
|
return s.validatedHeight.Load()
|
|
|
|
}
|
|
|
|
|
2021-01-29 14:33:24 +00:00
|
|
|
// Init initializes state root module at the given height.
|
|
|
|
func (s *Module) Init(height uint32, enableRefCount bool) error {
|
2021-02-01 16:00:07 +00:00
|
|
|
data, err := s.Store.Get([]byte{byte(storage.DataMPT), prefixValidated})
|
|
|
|
if err == nil {
|
|
|
|
s.validatedHeight.Store(binary.LittleEndian.Uint32(data))
|
|
|
|
}
|
|
|
|
|
2021-01-29 14:33:24 +00:00
|
|
|
var gcKey = []byte{byte(storage.DataMPT), prefixGC}
|
|
|
|
if height == 0 {
|
|
|
|
s.mpt = mpt.NewTrie(nil, enableRefCount, s.Store)
|
|
|
|
var val byte
|
|
|
|
if enableRefCount {
|
|
|
|
val = 1
|
|
|
|
}
|
|
|
|
s.currentLocal.Store(util.Uint256{})
|
|
|
|
return s.Store.Put(gcKey, []byte{val})
|
|
|
|
}
|
|
|
|
var hasRefCount bool
|
|
|
|
if v, err := s.Store.Get(gcKey); err == nil {
|
|
|
|
hasRefCount = v[0] != 0
|
|
|
|
}
|
|
|
|
if hasRefCount != enableRefCount {
|
|
|
|
return fmt.Errorf("KeepOnlyLatestState setting mismatch: old=%v, new=%v", hasRefCount, enableRefCount)
|
|
|
|
}
|
|
|
|
r, err := s.getStateRoot(makeStateRootKey(height))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
s.currentLocal.Store(r.Root)
|
|
|
|
s.localHeight.Store(r.Index)
|
|
|
|
s.mpt = mpt.NewTrie(mpt.NewHashNode(r.Root), enableRefCount, s.Store)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-08-17 15:16:10 +00:00
|
|
|
// CleanStorage removes all MPT-related data from the storage (MPT nodes, validated stateroots)
|
|
|
|
// except local stateroot for the current height and GC flag. This method is aimed to clean
|
|
|
|
// outdated MPT data before state sync process can be started.
|
|
|
|
// Note: this method is aimed to be called for genesis block only, an error is returned otherwice.
|
|
|
|
func (s *Module) CleanStorage() error {
|
|
|
|
if s.localHeight.Load() != 0 {
|
|
|
|
return fmt.Errorf("can't clean MPT data for non-genesis block: expected local stateroot height 0, got %d", s.localHeight.Load())
|
|
|
|
}
|
|
|
|
gcKey := []byte{byte(storage.DataMPT), prefixGC}
|
|
|
|
gcVal, err := s.Store.Get(gcKey)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to get GC flag: %w", err)
|
|
|
|
}
|
|
|
|
//
|
|
|
|
b := s.Store.Batch()
|
|
|
|
s.Store.Seek([]byte{byte(storage.DataMPT)}, func(k, _ []byte) {
|
|
|
|
// Must copy here, #1468.
|
|
|
|
key := slice.Copy(k)
|
|
|
|
b.Delete(key)
|
|
|
|
})
|
|
|
|
err = s.Store.PutBatch(b)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to remove outdated MPT-reated items: %w", err)
|
|
|
|
}
|
|
|
|
err = s.Store.Put(gcKey, gcVal)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to store GC flag: %w", err)
|
|
|
|
}
|
|
|
|
currentLocal := s.currentLocal.Load().(util.Uint256)
|
|
|
|
if !currentLocal.Equals(util.Uint256{}) {
|
|
|
|
err := s.addLocalStateRoot(s.Store, &state.MPTRoot{
|
|
|
|
Index: s.localHeight.Load(),
|
|
|
|
Root: currentLocal,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to store current local stateroot: %w", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-07-30 13:57:42 +00:00
|
|
|
// JumpToState performs jump to the state specified by given stateroot index.
|
|
|
|
func (s *Module) JumpToState(sr *state.MPTRoot, enableRefCount bool) error {
|
|
|
|
if err := s.addLocalStateRoot(s.Store, sr); err != nil {
|
|
|
|
return fmt.Errorf("failed to store local state root: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
data := make([]byte, 4)
|
|
|
|
binary.LittleEndian.PutUint32(data, sr.Index)
|
|
|
|
if err := s.Store.Put([]byte{byte(storage.DataMPT), prefixValidated}, data); err != nil {
|
|
|
|
return fmt.Errorf("failed to store validated height: %w", err)
|
|
|
|
}
|
|
|
|
s.validatedHeight.Store(sr.Index)
|
|
|
|
|
|
|
|
s.currentLocal.Store(sr.Root)
|
|
|
|
s.localHeight.Store(sr.Index)
|
|
|
|
s.mpt = mpt.NewTrie(mpt.NewHashNode(sr.Root), enableRefCount, s.Store)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-01-29 14:33:24 +00:00
|
|
|
// AddMPTBatch updates using provided batch.
|
2021-03-26 21:13:19 +00:00
|
|
|
func (s *Module) AddMPTBatch(index uint32, b mpt.Batch, cache *storage.MemCachedStore) (*mpt.Trie, *state.MPTRoot, error) {
|
|
|
|
mpt := *s.mpt
|
|
|
|
mpt.Store = cache
|
|
|
|
if _, err := mpt.PutBatch(b); err != nil {
|
|
|
|
return nil, nil, err
|
2021-01-29 14:33:24 +00:00
|
|
|
}
|
2021-03-26 21:13:19 +00:00
|
|
|
mpt.Flush()
|
|
|
|
sr := &state.MPTRoot{
|
2021-03-25 19:11:55 +00:00
|
|
|
Index: index,
|
2021-03-26 21:13:19 +00:00
|
|
|
Root: mpt.StateRoot(),
|
|
|
|
}
|
|
|
|
err := s.addLocalStateRoot(cache, sr)
|
2021-01-29 14:33:24 +00:00
|
|
|
if err != nil {
|
2021-03-26 21:13:19 +00:00
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
return &mpt, sr, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// UpdateCurrentLocal updates local caches using provided state root.
|
|
|
|
func (s *Module) UpdateCurrentLocal(mpt *mpt.Trie, sr *state.MPTRoot) {
|
|
|
|
s.mpt = mpt
|
|
|
|
s.currentLocal.Store(sr.Root)
|
|
|
|
s.localHeight.Store(sr.Index)
|
|
|
|
if s.bc.GetConfig().StateRootInHeader {
|
|
|
|
s.validatedHeight.Store(sr.Index)
|
|
|
|
updateStateHeightMetric(sr.Index)
|
2021-01-29 14:33:24 +00:00
|
|
|
}
|
|
|
|
}
|
2021-02-01 16:00:07 +00:00
|
|
|
|
|
|
|
// VerifyStateRoot checks if state root is valid.
|
|
|
|
func (s *Module) VerifyStateRoot(r *state.MPTRoot) error {
|
|
|
|
_, err := s.getStateRoot(makeStateRootKey(r.Index - 1))
|
|
|
|
if err != nil {
|
|
|
|
return errors.New("can't get previous state root")
|
|
|
|
}
|
2021-03-26 10:39:37 +00:00
|
|
|
if len(r.Witness) != 1 {
|
|
|
|
return errors.New("no witness")
|
|
|
|
}
|
2021-02-01 16:00:07 +00:00
|
|
|
return s.verifyWitness(r)
|
|
|
|
}
|
|
|
|
|
2021-07-07 13:14:49 +00:00
|
|
|
const maxVerificationGAS = 2_00000000
|
2021-02-01 16:00:07 +00:00
|
|
|
|
|
|
|
// verifyWitness verifies state root witness.
|
|
|
|
func (s *Module) verifyWitness(r *state.MPTRoot) error {
|
|
|
|
s.mtx.Lock()
|
|
|
|
h := s.getKeyCacheForHeight(r.Index).validatorsHash
|
|
|
|
s.mtx.Unlock()
|
2021-03-26 10:39:37 +00:00
|
|
|
return s.bc.VerifyWitness(h, r, &r.Witness[0], maxVerificationGAS)
|
2021-02-01 16:00:07 +00:00
|
|
|
}
|