github.com/Unheilbar/quorum@v1.0.0/core/state/database.go (about) 1 // Copyright 2017 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package state 18 19 import ( 20 "errors" 21 "fmt" 22 23 "github.com/VictoriaMetrics/fastcache" 24 "github.com/ethereum/go-ethereum/common" 25 "github.com/ethereum/go-ethereum/core/rawdb" 26 "github.com/ethereum/go-ethereum/ethdb" 27 "github.com/ethereum/go-ethereum/trie" 28 lru "github.com/hashicorp/golang-lru" 29 ) 30 31 const ( 32 // Number of codehash->size associations to keep. 33 codeSizeCacheSize = 100000 34 35 // Cache size granted for caching clean code. 36 codeCacheSize = 64 * 1024 * 1024 37 ) 38 39 // Database wraps access to tries and contract code. 40 type Database interface { 41 // OpenTrie opens the main account trie. 42 OpenTrie(root common.Hash) (Trie, error) 43 44 // OpenStorageTrie opens the storage trie of an account. 45 OpenStorageTrie(addrHash, root common.Hash) (Trie, error) 46 47 // CopyTrie returns an independent copy of the given trie. 48 CopyTrie(Trie) Trie 49 50 // ContractCode retrieves a particular contract's code. 51 ContractCode(addrHash, codeHash common.Hash) ([]byte, error) 52 53 // ContractCodeSize retrieves a particular contracts code's size. 54 ContractCodeSize(addrHash, codeHash common.Hash) (int, error) 55 56 // TrieDB retrieves the low level trie database used for data storage. 57 TrieDB() *trie.Database 58 59 // Quorum 60 // 61 // accountExtraDataLinker maintains mapping between root hash of the state trie 62 // and root hash of state.AccountExtraData trie. 63 AccountExtraDataLinker() rawdb.AccountExtraDataLinker 64 } 65 66 // Trie is a Ethereum Merkle Patricia trie. 67 type Trie interface { 68 // GetKey returns the sha3 preimage of a hashed key that was previously used 69 // to store a value. 70 // 71 // TODO(fjl): remove this when SecureTrie is removed 72 GetKey([]byte) []byte 73 74 // TryGet returns the value for key stored in the trie. The value bytes must 75 // not be modified by the caller. If a node was not found in the database, a 76 // trie.MissingNodeError is returned. 77 TryGet(key []byte) ([]byte, error) 78 79 // TryUpdate associates key with value in the trie. If value has length zero, any 80 // existing value is deleted from the trie. The value bytes must not be modified 81 // by the caller while they are stored in the trie. If a node was not found in the 82 // database, a trie.MissingNodeError is returned. 83 TryUpdate(key, value []byte) error 84 85 // TryDelete removes any existing value for key from the trie. If a node was not 86 // found in the database, a trie.MissingNodeError is returned. 87 TryDelete(key []byte) error 88 89 // Hash returns the root hash of the trie. It does not write to the database and 90 // can be used even if the trie doesn't have one. 91 Hash() common.Hash 92 93 // Commit writes all nodes to the trie's memory database, tracking the internal 94 // and external (for account tries) references. 95 Commit(onleaf trie.LeafCallback) (common.Hash, error) 96 97 // NodeIterator returns an iterator that returns nodes of the trie. Iteration 98 // starts at the key after the given start key. 99 NodeIterator(startKey []byte) trie.NodeIterator 100 101 // Prove constructs a Merkle proof for key. The result contains all encoded nodes 102 // on the path to the value at key. The value itself is also included in the last 103 // node and can be retrieved by verifying the proof. 104 // 105 // If the trie does not contain a value for key, the returned proof contains all 106 // nodes of the longest existing prefix of the key (at least the root), ending 107 // with the node that proves the absence of the key. 108 Prove(key []byte, fromLevel uint, proofDb ethdb.KeyValueWriter) error 109 } 110 111 // NewDatabase creates a backing store for state. The returned database is safe for 112 // concurrent use, but does not retain any recent trie nodes in memory. To keep some 113 // historical state in memory, use the NewDatabaseWithConfig constructor. 114 func NewDatabase(db ethdb.Database) Database { 115 return NewDatabaseWithConfig(db, nil) 116 } 117 118 // NewDatabaseWithConfig creates a backing store for state. The returned database 119 // is safe for concurrent use and retains a lot of collapsed RLP trie nodes in a 120 // large memory cache. 121 func NewDatabaseWithConfig(db ethdb.Database, config *trie.Config) Database { 122 csc, _ := lru.New(codeSizeCacheSize) 123 return &cachingDB{ 124 db: trie.NewDatabaseWithConfig(db, config), 125 codeSizeCache: csc, 126 codeCache: fastcache.New(codeCacheSize), 127 128 accountExtraDataLinker: rawdb.NewAccountExtraDataLinker(db), // Quorum 129 } 130 } 131 132 type cachingDB struct { 133 db *trie.Database 134 codeSizeCache *lru.Cache 135 codeCache *fastcache.Cache 136 137 // Quorum 138 // 139 // accountExtraDataLinker maintains mapping between state root and state.AccountExtraData root. 140 // As this struct is the backing store for state, this gives the reference to the linker when needed. 141 accountExtraDataLinker rawdb.AccountExtraDataLinker 142 } 143 144 func (db *cachingDB) AccountExtraDataLinker() rawdb.AccountExtraDataLinker { 145 return db.accountExtraDataLinker 146 } 147 148 // OpenTrie opens the main account trie at a specific root hash. 149 func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) { 150 tr, err := trie.NewSecure(root, db.db) 151 if err != nil { 152 return nil, err 153 } 154 return tr, nil 155 } 156 157 // OpenStorageTrie opens the storage trie of an account. 158 func (db *cachingDB) OpenStorageTrie(addrHash, root common.Hash) (Trie, error) { 159 tr, err := trie.NewSecure(root, db.db) 160 if err != nil { 161 return nil, err 162 } 163 return tr, nil 164 } 165 166 // CopyTrie returns an independent copy of the given trie. 167 func (db *cachingDB) CopyTrie(t Trie) Trie { 168 switch t := t.(type) { 169 case *trie.SecureTrie: 170 return t.Copy() 171 default: 172 panic(fmt.Errorf("unknown trie type %T", t)) 173 } 174 } 175 176 // ContractCode retrieves a particular contract's code. 177 func (db *cachingDB) ContractCode(addrHash, codeHash common.Hash) ([]byte, error) { 178 if code := db.codeCache.Get(nil, codeHash.Bytes()); len(code) > 0 { 179 return code, nil 180 } 181 code := rawdb.ReadCode(db.db.DiskDB(), codeHash) 182 if len(code) > 0 { 183 db.codeCache.Set(codeHash.Bytes(), code) 184 db.codeSizeCache.Add(codeHash, len(code)) 185 return code, nil 186 } 187 return nil, errors.New("not found") 188 } 189 190 // ContractCodeWithPrefix retrieves a particular contract's code. If the 191 // code can't be found in the cache, then check the existence with **new** 192 // db scheme. 193 func (db *cachingDB) ContractCodeWithPrefix(addrHash, codeHash common.Hash) ([]byte, error) { 194 if code := db.codeCache.Get(nil, codeHash.Bytes()); len(code) > 0 { 195 return code, nil 196 } 197 code := rawdb.ReadCodeWithPrefix(db.db.DiskDB(), codeHash) 198 if len(code) > 0 { 199 db.codeCache.Set(codeHash.Bytes(), code) 200 db.codeSizeCache.Add(codeHash, len(code)) 201 return code, nil 202 } 203 return nil, errors.New("not found") 204 } 205 206 // ContractCodeSize retrieves a particular contracts code's size. 207 func (db *cachingDB) ContractCodeSize(addrHash, codeHash common.Hash) (int, error) { 208 if cached, ok := db.codeSizeCache.Get(codeHash); ok { 209 return cached.(int), nil 210 } 211 code, err := db.ContractCode(addrHash, codeHash) 212 return len(code), err 213 } 214 215 // TrieDB retrieves any intermediate trie-node caching layer. 216 func (db *cachingDB) TrieDB() *trie.Database { 217 return db.db 218 }