126 lines
4.4 KiB
Go
126 lines
4.4 KiB
Go
package mpt
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/storage"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
"github.com/nspcc-dev/neo-go/pkg/util/slice"
|
|
)
|
|
|
|
// TrieStore is an MPT-based storage implementation for storing and retrieving
|
|
// historic blockchain data. TrieStore is supposed to be used within transaction
|
|
// script invocations only, thus only contract storage related operations are
|
|
// supported. All storage-related operations are being performed using historical
|
|
// storage data retrieved from MPT state. TrieStore is read-only and does not
|
|
// support put-related operations, thus, it should always be wrapped into
|
|
// MemCachedStore for proper puts handling. TrieStore never changes the provided
|
|
// backend store.
|
|
type TrieStore struct {
|
|
trie *Trie
|
|
}
|
|
|
|
// ErrForbiddenTrieStoreOperation is returned when operation is not supposed to
|
|
// be performed over MPT-based Store.
|
|
var ErrForbiddenTrieStoreOperation = errors.New("operation is not allowed to be performed over TrieStore")
|
|
|
|
// NewTrieStore returns a new ready to use MPT-backed storage.
|
|
func NewTrieStore(root util.Uint256, mode TrieMode, backed storage.Store) *TrieStore {
|
|
cache, ok := backed.(*storage.MemCachedStore)
|
|
if !ok {
|
|
cache = storage.NewMemCachedStore(backed)
|
|
}
|
|
tr := NewTrie(NewHashNode(root), mode, cache)
|
|
return &TrieStore{
|
|
trie: tr,
|
|
}
|
|
}
|
|
|
|
// Get implements the Store interface.
|
|
func (m *TrieStore) Get(key []byte) ([]byte, error) {
|
|
if len(key) == 0 {
|
|
return nil, fmt.Errorf("%w: Get is supported only for contract storage items", ErrForbiddenTrieStoreOperation)
|
|
}
|
|
switch storage.KeyPrefix(key[0]) {
|
|
case storage.STStorage, storage.STTempStorage:
|
|
res, err := m.trie.Get(key[1:])
|
|
if err != nil && errors.Is(err, ErrNotFound) {
|
|
// Mimic the real storage behaviour.
|
|
return nil, storage.ErrKeyNotFound
|
|
}
|
|
return res, err
|
|
default:
|
|
return nil, fmt.Errorf("%w: Get is supported only for contract storage items", ErrForbiddenTrieStoreOperation)
|
|
}
|
|
}
|
|
|
|
// PutChangeSet implements the Store interface.
|
|
func (m *TrieStore) PutChangeSet(puts map[string][]byte, stor map[string][]byte) error {
|
|
// Only Get and Seek should be supported, as TrieStore is read-only and is always
|
|
// should be wrapped by MemCachedStore to properly support put operations (if any).
|
|
return fmt.Errorf("%w: PutChangeSet is not supported", ErrForbiddenTrieStoreOperation)
|
|
}
|
|
|
|
// Seek implements the Store interface.
|
|
func (m *TrieStore) Seek(rng storage.SeekRange, f func(k, v []byte) bool) {
|
|
prefix := storage.KeyPrefix(rng.Prefix[0])
|
|
if prefix != storage.STStorage && prefix != storage.STTempStorage { // Prefix is always non-empty.
|
|
panic(fmt.Errorf("%w: Seek is supported only for contract storage items", ErrForbiddenTrieStoreOperation))
|
|
}
|
|
prefixP := toNibbles(rng.Prefix[1:])
|
|
fromP := []byte{}
|
|
if len(rng.Start) > 0 {
|
|
fromP = toNibbles(rng.Start)
|
|
}
|
|
_, start, path, err := m.trie.getWithPath(m.trie.root, prefixP, false)
|
|
if err != nil {
|
|
// Failed to determine the start node => no matching items.
|
|
return
|
|
}
|
|
path = path[len(prefixP):]
|
|
|
|
if len(fromP) > 0 {
|
|
if len(path) <= len(fromP) && bytes.HasPrefix(fromP, path) {
|
|
fromP = fromP[len(path):]
|
|
} else if len(path) > len(fromP) && bytes.HasPrefix(path, fromP) {
|
|
fromP = []byte{}
|
|
} else {
|
|
cmp := bytes.Compare(path, fromP)
|
|
if cmp < 0 == rng.Backwards {
|
|
// No matching items.
|
|
return
|
|
}
|
|
fromP = []byte{}
|
|
}
|
|
}
|
|
|
|
b := NewBillet(m.trie.root.Hash(), m.trie.mode, 0, m.trie.Store)
|
|
process := func(pathToNode []byte, node Node, _ []byte) bool {
|
|
if leaf, ok := node.(*LeafNode); ok {
|
|
// (*Billet).traverse includes `from` path into the result if so. It's OK for Seek, so shouldn't be filtered out.
|
|
kv := storage.KeyValue{
|
|
Key: append(slice.Copy(rng.Prefix), pathToNode...), // Do not cut prefix.
|
|
Value: slice.Copy(leaf.value),
|
|
}
|
|
return !f(kv.Key, kv.Value) // Should return whether to stop.
|
|
}
|
|
return false
|
|
}
|
|
_, err = b.traverse(start, path, fromP, process, false, rng.Backwards)
|
|
if err != nil && !errors.Is(err, errStop) {
|
|
panic(fmt.Errorf("failed to perform Seek operation on TrieStore: %w", err))
|
|
}
|
|
}
|
|
|
|
// SeekGC implements the Store interface.
|
|
func (m *TrieStore) SeekGC(rng storage.SeekRange, keep func(k, v []byte) bool) error {
|
|
return fmt.Errorf("%w: SeekGC is not supported", ErrForbiddenTrieStoreOperation)
|
|
}
|
|
|
|
// Close implements the Store interface.
|
|
func (m *TrieStore) Close() error {
|
|
m.trie = nil
|
|
return nil
|
|
}
|