@ -25,25 +25,35 @@ import (
"github.com/ethereum/go-ethereum/rlp"
)
// SecureTrie wraps a trie with key hashing. In a secure trie, all
// SecureTrie is the old name of StateTrie.
// Deprecated: use StateTrie.
type SecureTrie = StateTrie
// NewSecure creates a new StateTrie.
// Deprecated: use NewStateTrie.
func NewSecure ( owner common . Hash , root common . Hash , db * Database ) ( * SecureTrie , error ) {
return NewStateTrie ( owner , root , db )
}
// StateTrie wraps a trie with key hashing. In a secure trie, all
// access operations hash the key using keccak256. This prevents
// calling code from creating long chains of nodes that
// increase the access time.
//
// Contrary to a regular trie, a SecureTrie can only be created with
// Contrary to a regular trie, a Stat eTrie can only be created with
// New and must have an attached database. The database also stores
// the preimage of each key.
//
// SecureTrie is not safe for concurrent use.
type SecureTrie struct {
// Stat eTrie is not safe for concurrent use.
type Stat eTrie struct {
trie Trie
preimages * preimageStore
hashKeyBuf [ common . HashLength ] byte
secKeyCache map [ string ] [ ] byte
secKeyCacheOwner * Secur eTrie // Pointer to self, replace the key cache on mismatch
secKeyCacheOwner * Stat eTrie // Pointer to self, replace the key cache on mismatch
}
// NewSecur e creates a trie with an existing root node from a backing database
// NewStateTri e creates a trie with an existing root node from a backing database
// and optional intermediate in-memory node pool.
//
// If root is the zero hash or the sha3 hash of an empty string, the
@ -54,7 +64,7 @@ type SecureTrie struct {
// Loaded nodes are kept around until their 'cache generation' expires.
// A new cache generation is created by each call to Commit.
// cachelimit sets the number of past cache generations to keep.
func NewSecur e ( owner common . Hash , root common . Hash , db * Database ) ( * Secur eTrie , error ) {
func NewStateTri e ( owner common . Hash , root common . Hash , db * Database ) ( * Stat eTrie , error ) {
if db == nil {
panic ( "trie.NewSecure called without a database" )
}
@ -62,12 +72,12 @@ func NewSecure(owner common.Hash, root common.Hash, db *Database) (*SecureTrie,
if err != nil {
return nil , err
}
return & Secur eTrie { trie : * trie , preimages : db . preimages } , nil
return & Stat eTrie { trie : * trie , preimages : db . preimages } , nil
}
// Get returns the value for key stored in the trie.
// The value bytes must not be modified by the caller.
func ( t * Secur eTrie ) Get ( key [ ] byte ) [ ] byte {
func ( t * Stat eTrie ) Get ( key [ ] byte ) [ ] byte {
res , err := t . TryGet ( key )
if err != nil {
log . Error ( fmt . Sprintf ( "Unhandled trie error: %v" , err ) )
@ -78,19 +88,50 @@ func (t *SecureTrie) Get(key []byte) []byte {
// TryGet returns the value for key stored in the trie.
// The value bytes must not be modified by the caller.
// If a node was not found in the database, a MissingNodeError is returned.
func ( t * Secur eTrie ) TryGet ( key [ ] byte ) ( [ ] byte , error ) {
func ( t * Stat eTrie ) TryGet ( key [ ] byte ) ( [ ] byte , error ) {
return t . trie . TryGet ( t . hashKey ( key ) )
}
func ( t * StateTrie ) TryGetAccount ( key [ ] byte ) ( * types . StateAccount , error ) {
var ret types . StateAccount
res , err := t . trie . TryGet ( t . hashKey ( key ) )
if err != nil {
log . Error ( fmt . Sprintf ( "Unhandled trie error: %v" , err ) )
return & ret , err
}
if res == nil {
return nil , nil
}
err = rlp . DecodeBytes ( res , & ret )
return & ret , err
}
// TryGetAccountWithPreHashedKey does the same thing as TryGetAccount, however
// it expects a key that is already hashed. This constitutes an abstraction leak,
// since the client code needs to know the key format.
func ( t * StateTrie ) TryGetAccountWithPreHashedKey ( key [ ] byte ) ( * types . StateAccount , error ) {
var ret types . StateAccount
res , err := t . trie . TryGet ( key )
if err != nil {
log . Error ( fmt . Sprintf ( "Unhandled trie error: %v" , err ) )
return & ret , err
}
if res == nil {
return nil , nil
}
err = rlp . DecodeBytes ( res , & ret )
return & ret , err
}
// TryGetNode attempts to retrieve a trie node by compact-encoded path. It is not
// possible to use keybyte-encoding as the path might contain odd nibbles.
func ( t * SecureTrie ) TryGetNode ( path [ ] byte ) ( [ ] byte , int , error ) {
func ( t * Stat eTrie ) TryGetNode ( path [ ] byte ) ( [ ] byte , int , error ) {
return t . trie . TryGetNode ( path )
}
// TryUpdateAccount account will abstract the write of an account to the
// secure trie.
func ( t * SecureTrie ) TryUpdateAccount ( key [ ] byte , acc * types . StateAccount ) error {
func ( t * Stat eTrie ) TryUpdateAccount ( key [ ] byte , acc * types . StateAccount ) error {
hk := t . hashKey ( key )
data , err := rlp . EncodeToBytes ( acc )
if err != nil {
@ -109,7 +150,7 @@ func (t *SecureTrie) TryUpdateAccount(key []byte, acc *types.StateAccount) error
//
// The value bytes must not be modified by the caller while they are
// stored in the trie.
func ( t * Secur eTrie ) Update ( key , value [ ] byte ) {
func ( t * Stat eTrie ) Update ( key , value [ ] byte ) {
if err := t . TryUpdate ( key , value ) ; err != nil {
log . Error ( fmt . Sprintf ( "Unhandled trie error: %v" , err ) )
}
@ -123,7 +164,7 @@ func (t *SecureTrie) Update(key, value []byte) {
// stored in the trie.
//
// If a node was not found in the database, a MissingNodeError is returned.
func ( t * Secur eTrie ) TryUpdate ( key , value [ ] byte ) error {
func ( t * Stat eTrie ) TryUpdate ( key , value [ ] byte ) error {
hk := t . hashKey ( key )
err := t . trie . TryUpdate ( hk , value )
if err != nil {
@ -134,7 +175,7 @@ func (t *SecureTrie) TryUpdate(key, value []byte) error {
}
// Delete removes any existing value for key from the trie.
func ( t * Secur eTrie ) Delete ( key [ ] byte ) {
func ( t * Stat eTrie ) Delete ( key [ ] byte ) {
if err := t . TryDelete ( key ) ; err != nil {
log . Error ( fmt . Sprintf ( "Unhandled trie error: %v" , err ) )
}
@ -142,7 +183,7 @@ func (t *SecureTrie) Delete(key []byte) {
// TryDelete removes any existing value for key from the trie.
// If a node was not found in the database, a MissingNodeError is returned.
func ( t * Secur eTrie ) TryDelete ( key [ ] byte ) error {
func ( t * Stat eTrie ) TryDelete ( key [ ] byte ) error {
hk := t . hashKey ( key )
delete ( t . getSecKeyCache ( ) , string ( hk ) )
return t . trie . TryDelete ( hk )
@ -150,7 +191,7 @@ func (t *SecureTrie) TryDelete(key []byte) error {
// GetKey returns the sha3 preimage of a hashed key that was
// previously used to store a value.
func ( t * Secur eTrie ) GetKey ( shaKey [ ] byte ) [ ] byte {
func ( t * Stat eTrie ) GetKey ( shaKey [ ] byte ) [ ] byte {
if key , ok := t . getSecKeyCache ( ) [ string ( shaKey ) ] ; ok {
return key
}
@ -167,7 +208,7 @@ func (t *SecureTrie) GetKey(shaKey []byte) []byte {
// All cached preimages will be also flushed if preimages recording is enabled.
// Once the trie is committed, it's not usable anymore. A new trie must
// be created with new root and updated trie database for following usage
func ( t * Secur eTrie ) Commit ( collectLeaf bool ) ( common . Hash , * NodeSet , error ) {
func ( t * Stat eTrie ) Commit ( collectLeaf bool ) ( common . Hash , * NodeSet , error ) {
// Write all the pre-images to the actual disk database
if len ( t . getSecKeyCache ( ) ) > 0 {
if t . preimages != nil {
@ -183,15 +224,15 @@ func (t *SecureTrie) Commit(collectLeaf bool) (common.Hash, *NodeSet, error) {
return t . trie . Commit ( collectLeaf )
}
// Hash returns the root hash of Secur eTrie. It does not write to the
// Hash returns the root hash of Stat eTrie. It does not write to the
// database and can be used even if the trie doesn't have one.
func ( t * Secur eTrie ) Hash ( ) common . Hash {
func ( t * Stat eTrie ) Hash ( ) common . Hash {
return t . trie . Hash ( )
}
// Copy returns a copy of Secur eTrie.
func ( t * Secur eTrie ) Copy ( ) * Secur eTrie {
return & Secur eTrie {
// Copy returns a copy of Stat eTrie.
func ( t * Stat eTrie ) Copy ( ) * Stat eTrie {
return & Stat eTrie {
trie : * t . trie . Copy ( ) ,
preimages : t . preimages ,
secKeyCache : t . secKeyCache ,
@ -200,14 +241,14 @@ func (t *SecureTrie) Copy() *SecureTrie {
// NodeIterator returns an iterator that returns nodes of the underlying trie. Iteration
// starts at the key after the given start key.
func ( t * Secur eTrie ) NodeIterator ( start [ ] byte ) NodeIterator {
func ( t * Stat eTrie ) NodeIterator ( start [ ] byte ) NodeIterator {
return t . trie . NodeIterator ( start )
}
// hashKey returns the hash of key as an ephemeral buffer.
// The caller must not hold onto the return value because it will become
// invalid on the next call to hashKey or secKey.
func ( t * Secur eTrie ) hashKey ( key [ ] byte ) [ ] byte {
func ( t * Stat eTrie ) hashKey ( key [ ] byte ) [ ] byte {
h := newHasher ( false )
h . sha . Reset ( )
h . sha . Write ( key )
@ -219,7 +260,7 @@ func (t *SecureTrie) hashKey(key []byte) []byte {
// getSecKeyCache returns the current secure key cache, creating a new one if
// ownership changed (i.e. the current secure trie is a copy of another owning
// the actual cache).
func ( t * Secur eTrie ) getSecKeyCache ( ) map [ string ] [ ] byte {
func ( t * Stat eTrie ) getSecKeyCache ( ) map [ string ] [ ] byte {
if t != t . secKeyCacheOwner {
t . secKeyCacheOwner = t
t . secKeyCache = make ( map [ string ] [ ] byte )
Guillaume Ballet
2 years ago
committed by
GitHub