You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
293 lines
7.2 KiB
293 lines
7.2 KiB
package state
|
|
|
|
import (
|
|
"bytes"
|
|
"sort"
|
|
|
|
acm "github.com/tendermint/tendermint/account"
|
|
. "github.com/tendermint/tendermint/common"
|
|
dbm "github.com/tendermint/tendermint/db"
|
|
"github.com/tendermint/tendermint/merkle"
|
|
"github.com/tendermint/tendermint/types"
|
|
"github.com/tendermint/tendermint/wire"
|
|
)
|
|
|
|
func makeStorage(db dbm.DB, root []byte) merkle.Tree {
|
|
storage := merkle.NewIAVLTree(
|
|
wire.BasicCodec,
|
|
wire.BasicCodec,
|
|
1024,
|
|
db,
|
|
)
|
|
storage.Load(root)
|
|
return storage
|
|
}
|
|
|
|
// The blockcache helps prevent unnecessary IAVLTree updates and garbage generation.
|
|
type BlockCache struct {
|
|
db dbm.DB
|
|
backend *State
|
|
accounts map[string]accountInfo
|
|
storages map[Tuple256]storageInfo
|
|
names map[string]nameInfo
|
|
}
|
|
|
|
func NewBlockCache(backend *State) *BlockCache {
|
|
return &BlockCache{
|
|
db: backend.DB,
|
|
backend: backend,
|
|
accounts: make(map[string]accountInfo),
|
|
storages: make(map[Tuple256]storageInfo),
|
|
names: make(map[string]nameInfo),
|
|
}
|
|
}
|
|
|
|
func (cache *BlockCache) State() *State {
|
|
return cache.backend
|
|
}
|
|
|
|
//-------------------------------------
|
|
// BlockCache.account
|
|
|
|
func (cache *BlockCache) GetAccount(addr []byte) *acm.Account {
|
|
acc, _, removed, _ := cache.accounts[string(addr)].unpack()
|
|
if removed {
|
|
return nil
|
|
} else if acc != nil {
|
|
return acc
|
|
} else {
|
|
acc = cache.backend.GetAccount(addr)
|
|
cache.accounts[string(addr)] = accountInfo{acc, nil, false, false}
|
|
return acc
|
|
}
|
|
}
|
|
|
|
func (cache *BlockCache) UpdateAccount(acc *acm.Account) {
|
|
addr := acc.Address
|
|
_, storage, removed, _ := cache.accounts[string(addr)].unpack()
|
|
if removed {
|
|
PanicSanity("UpdateAccount on a removed account")
|
|
}
|
|
cache.accounts[string(addr)] = accountInfo{acc, storage, false, true}
|
|
}
|
|
|
|
func (cache *BlockCache) RemoveAccount(addr []byte) {
|
|
_, _, removed, _ := cache.accounts[string(addr)].unpack()
|
|
if removed {
|
|
PanicSanity("RemoveAccount on a removed account")
|
|
}
|
|
cache.accounts[string(addr)] = accountInfo{nil, nil, true, false}
|
|
}
|
|
|
|
// BlockCache.account
|
|
//-------------------------------------
|
|
// BlockCache.storage
|
|
|
|
func (cache *BlockCache) GetStorage(addr Word256, key Word256) (value Word256) {
|
|
// Check cache
|
|
info, ok := cache.storages[Tuple256{addr, key}]
|
|
if ok {
|
|
return info.value
|
|
}
|
|
|
|
// Get or load storage
|
|
acc, storage, removed, dirty := cache.accounts[string(addr.Postfix(20))].unpack()
|
|
if removed {
|
|
PanicSanity("GetStorage() on removed account")
|
|
}
|
|
if acc != nil && storage == nil {
|
|
storage = makeStorage(cache.db, acc.StorageRoot)
|
|
cache.accounts[string(addr.Postfix(20))] = accountInfo{acc, storage, false, dirty}
|
|
} else if acc == nil {
|
|
return Zero256
|
|
}
|
|
|
|
// Load and set cache
|
|
_, val_ := storage.Get(key.Bytes())
|
|
value = Zero256
|
|
if val_ != nil {
|
|
value = LeftPadWord256(val_.([]byte))
|
|
}
|
|
cache.storages[Tuple256{addr, key}] = storageInfo{value, false}
|
|
return value
|
|
}
|
|
|
|
// NOTE: Set value to zero to removed from the trie.
|
|
func (cache *BlockCache) SetStorage(addr Word256, key Word256, value Word256) {
|
|
_, _, removed, _ := cache.accounts[string(addr.Postfix(20))].unpack()
|
|
if removed {
|
|
PanicSanity("SetStorage() on a removed account")
|
|
}
|
|
cache.storages[Tuple256{addr, key}] = storageInfo{value, true}
|
|
}
|
|
|
|
// BlockCache.storage
|
|
//-------------------------------------
|
|
// BlockCache.names
|
|
|
|
func (cache *BlockCache) GetNameRegEntry(name string) *types.NameRegEntry {
|
|
entry, removed, _ := cache.names[name].unpack()
|
|
if removed {
|
|
return nil
|
|
} else if entry != nil {
|
|
return entry
|
|
} else {
|
|
entry = cache.backend.GetNameRegEntry(name)
|
|
cache.names[name] = nameInfo{entry, false, false}
|
|
return entry
|
|
}
|
|
}
|
|
|
|
func (cache *BlockCache) UpdateNameRegEntry(entry *types.NameRegEntry) {
|
|
name := entry.Name
|
|
cache.names[name] = nameInfo{entry, false, true}
|
|
}
|
|
|
|
func (cache *BlockCache) RemoveNameRegEntry(name string) {
|
|
_, removed, _ := cache.names[name].unpack()
|
|
if removed {
|
|
PanicSanity("RemoveNameRegEntry on a removed entry")
|
|
}
|
|
cache.names[name] = nameInfo{nil, true, false}
|
|
}
|
|
|
|
// BlockCache.names
|
|
//-------------------------------------
|
|
|
|
// CONTRACT the updates are in deterministic order.
|
|
func (cache *BlockCache) Sync() {
|
|
|
|
// Determine order for storage updates
|
|
// The address comes first so it'll be grouped.
|
|
storageKeys := make([]Tuple256, 0, len(cache.storages))
|
|
for keyTuple := range cache.storages {
|
|
storageKeys = append(storageKeys, keyTuple)
|
|
}
|
|
Tuple256Slice(storageKeys).Sort()
|
|
|
|
// Update storage for all account/key.
|
|
// Later we'll iterate over all the users and save storage + update storage root.
|
|
var (
|
|
curAddr Word256
|
|
curAcc *acm.Account
|
|
curAccRemoved bool
|
|
curStorage merkle.Tree
|
|
)
|
|
for _, storageKey := range storageKeys {
|
|
addr, key := Tuple256Split(storageKey)
|
|
if addr != curAddr || curAcc == nil {
|
|
acc, storage, removed, _ := cache.accounts[string(addr.Postfix(20))].unpack()
|
|
if !removed && storage == nil {
|
|
storage = makeStorage(cache.db, acc.StorageRoot)
|
|
}
|
|
curAddr = addr
|
|
curAcc = acc
|
|
curAccRemoved = removed
|
|
curStorage = storage
|
|
}
|
|
if curAccRemoved {
|
|
continue
|
|
}
|
|
value, dirty := cache.storages[storageKey].unpack()
|
|
if !dirty {
|
|
continue
|
|
}
|
|
if value.IsZero() {
|
|
curStorage.Remove(key.Bytes())
|
|
} else {
|
|
curStorage.Set(key.Bytes(), value.Bytes())
|
|
cache.accounts[string(addr.Postfix(20))] = accountInfo{curAcc, curStorage, false, true}
|
|
}
|
|
}
|
|
|
|
// Determine order for accounts
|
|
addrStrs := []string{}
|
|
for addrStr := range cache.accounts {
|
|
addrStrs = append(addrStrs, addrStr)
|
|
}
|
|
sort.Strings(addrStrs)
|
|
|
|
// Update or delete accounts.
|
|
for _, addrStr := range addrStrs {
|
|
acc, storage, removed, dirty := cache.accounts[addrStr].unpack()
|
|
if removed {
|
|
removed := cache.backend.RemoveAccount([]byte(addrStr))
|
|
if !removed {
|
|
PanicCrisis(Fmt("Could not remove account to be removed: %X", acc.Address))
|
|
}
|
|
} else {
|
|
if acc == nil {
|
|
continue
|
|
}
|
|
if storage != nil {
|
|
newStorageRoot := storage.Save()
|
|
if !bytes.Equal(newStorageRoot, acc.StorageRoot) {
|
|
acc.StorageRoot = newStorageRoot
|
|
dirty = true
|
|
}
|
|
}
|
|
if dirty {
|
|
cache.backend.UpdateAccount(acc)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Determine order for names
|
|
// note names may be of any length less than some limit
|
|
nameStrs := []string{}
|
|
for nameStr := range cache.names {
|
|
nameStrs = append(nameStrs, nameStr)
|
|
}
|
|
sort.Strings(nameStrs)
|
|
|
|
// Update or delete names.
|
|
for _, nameStr := range nameStrs {
|
|
entry, removed, dirty := cache.names[nameStr].unpack()
|
|
if removed {
|
|
removed := cache.backend.RemoveNameRegEntry(nameStr)
|
|
if !removed {
|
|
PanicCrisis(Fmt("Could not remove namereg entry to be removed: %s", nameStr))
|
|
}
|
|
} else {
|
|
if entry == nil {
|
|
continue
|
|
}
|
|
if dirty {
|
|
cache.backend.UpdateNameRegEntry(entry)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type accountInfo struct {
|
|
account *acm.Account
|
|
storage merkle.Tree
|
|
removed bool
|
|
dirty bool
|
|
}
|
|
|
|
func (accInfo accountInfo) unpack() (*acm.Account, merkle.Tree, bool, bool) {
|
|
return accInfo.account, accInfo.storage, accInfo.removed, accInfo.dirty
|
|
}
|
|
|
|
type storageInfo struct {
|
|
value Word256
|
|
dirty bool
|
|
}
|
|
|
|
func (stjInfo storageInfo) unpack() (Word256, bool) {
|
|
return stjInfo.value, stjInfo.dirty
|
|
}
|
|
|
|
type nameInfo struct {
|
|
name *types.NameRegEntry
|
|
removed bool
|
|
dirty bool
|
|
}
|
|
|
|
func (nInfo nameInfo) unpack() (*types.NameRegEntry, bool, bool) {
|
|
return nInfo.name, nInfo.removed, nInfo.dirty
|
|
}
|