+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/log"

+ // Cache will initially contain [refHash.parent],

+ // Then fill up with [refHash.p, refHash.pp, refHash.ppp, ...]

+ var cache []common.Hash

+ if len(cache) == 0 {

+ cache = append(cache, ref.ParentHash)

+ if idx := ref.Number.Uint64() - n - 1; idx < uint64(len(cache)) {

+ return cache[idx]

+ // No luck in the cache, but we can start iterating from the last element we already know

+ lastKnownHash := cache[len(cache)-1]

+ lastKnownNumber := ref.Number.Uint64() - uint64(len(cache))

+

+ for {

+ header := chain.GetHeader(lastKnownHash, lastKnownNumber)

+ if header == nil {

+ break

+ }

+ cache = append(cache, header.ParentHash)

+ lastKnownHash = header.ParentHash

+ lastKnownNumber = header.Number.Uint64() - 1

+ if n == lastKnownNumber {

+ return lastKnownHash

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/common/hexutil"

+ "github.com/ethereum/go-ethereum/common/math"

+ "github.com/ethereum/go-ethereum/crypto"

+ "github.com/ethereum/go-ethereum/ethdb"

+ "github.com/ethereum/go-ethereum/log"

+ "github.com/ethereum/go-ethereum/rlp"

+ "github.com/ethereum/go-ethereum/trie"

+ if _, err := state.New(header.Root, state.NewDatabaseWithCache(db, 0, ""), nil); err != nil {

+ if err := newcfg.CheckConfigForkOrder(); err != nil {

+ return newcfg, common.Hash{}, err

+ case ghash == params.RopstenGenesisHash:

+ return params.RopstenChainConfig

+ case ghash == params.RinkebyGenesisHash:

+ return params.RinkebyChainConfig

+ case ghash == params.GoerliGenesisHash:

+ return params.GoerliChainConfig

+ case ghash == params.YoloV1GenesisHash:

+ return params.YoloV1ChainConfig

+ statedb, _ := state.New(common.Hash{}, state.NewDatabase(db), nil)

+ statedb.Database().TrieDB().Commit(root, true, nil)

+ return types.NewBlock(head, nil, nil, nil, new(trie.Trie), nil)

+ config := g.Config

+ if config == nil {

+ config = params.AllEthashProtocolChanges

+ }

+ if err := config.CheckConfigForkOrder(); err != nil {

+ return nil, err

+ }

+// DefaultRopstenGenesisBlock returns the Ropsten network genesis block.

+func DefaultRopstenGenesisBlock() *Genesis {

+ Config: params.RopstenChainConfig,

+ Alloc: decodePrealloc(ropstenAllocData),

+func DefaultYoloV1GenesisBlock() *Genesis {

+ return &Genesis{

+ Config: params.YoloV1ChainConfig,

+ Timestamp: 0x5ed754f1,

+ ExtraData: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000000000000008a37866fd3627c9205a37c8685666f32ec07bb1b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),

+ GasLimit: 0x47b760,

+ Difficulty: big.NewInt(1),

+ Alloc: decodePrealloc(yoloV1AllocData),

+ }

+}

+

+// DeveloperGenesisBlock returns the 'geth --dev' genesis block.

+ GasLimit: 11500000,

+ common.BytesToAddress([]byte{9}): {Balance: big.NewInt(1)}, // BLAKE2b

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/crypto"

+ "github.com/ethereum/go-ethereum/ethdb"

+ "github.com/ethereum/go-ethereum/log"

+ "github.com/ethereum/go-ethereum/rlp"

+ it := db.NewIterator(prefix, nil)

+// ReadAllCanonicalHashes retrieves all canonical number and hash mappings at the

+// certain chain range. If the accumulated entries reaches the given threshold,

+// abort the iteration and return the semi-finish result.

+func ReadAllCanonicalHashes(db ethdb.Iteratee, from uint64, to uint64, limit int) ([]uint64, []common.Hash) {

+ // Short circuit if the limit is 0.

+ if limit == 0 {

+ return nil, nil

+ }

+ var (

+ numbers []uint64

+ hashes []common.Hash

+ )

+ // Construct the key prefix of start point.

+ start, end := headerHashKey(from), headerHashKey(to)

+ it := db.NewIterator(nil, start)

+ defer it.Release()

+

+ for it.Next() {

+ if bytes.Compare(it.Key(), end) >= 0 {

+ break

+ }

+ if key := it.Key(); len(key) == len(headerPrefix)+8+1 && bytes.Equal(key[len(key)-1:], headerHashSuffix) {

+ numbers = append(numbers, binary.BigEndian.Uint64(key[len(headerPrefix):len(headerPrefix)+8]))

+ hashes = append(hashes, common.BytesToHash(it.Value()))

+ // If the accumulated entries reaches the limit threshold, return.

+ if len(numbers) >= limit {

+ break

+ }

+ }

+ }

+ return numbers, hashes

+}

+

+// ReadLastPivotNumber retrieves the number of the last pivot block. If the node

+// full synced, the last pivot will always be nil.

+func ReadLastPivotNumber(db ethdb.KeyValueReader) *uint64 {

+ data, _ := db.Get(lastPivotKey)

+ if len(data) == 0 {

+ return nil

+ }

+ var pivot uint64

+ if err := rlp.DecodeBytes(data, &pivot); err != nil {

+ log.Error("Invalid pivot block number in database", "err", err)

+ return nil

+ }

+ return &pivot

+}

+

+// WriteLastPivotNumber stores the number of the last pivot block.

+func WriteLastPivotNumber(db ethdb.KeyValueWriter, pivot uint64) {

+ enc, err := rlp.EncodeToBytes(pivot)

+ if err != nil {

+ log.Crit("Failed to encode pivot block number", "err", err)

+ }

+ if err := db.Put(lastPivotKey, enc); err != nil {

+ log.Crit("Failed to store pivot block number", "err", err)

+ }

+}

+

+// ReadTxIndexTail retrieves the number of oldest indexed block

+// whose transaction indices has been indexed. If the corresponding entry

+// is non-existent in database it means the indexing has been finished.

+func ReadTxIndexTail(db ethdb.KeyValueReader) *uint64 {

+ data, _ := db.Get(txIndexTailKey)

+ if len(data) != 8 {

+ return nil

+ }

+ number := binary.BigEndian.Uint64(data)

+ return &number

+}

+

+// WriteTxIndexTail stores the number of oldest indexed block

+// into database.

+func WriteTxIndexTail(db ethdb.KeyValueWriter, number uint64) {

+ if err := db.Put(txIndexTailKey, encodeBlockNumber(number)); err != nil {

+ log.Crit("Failed to store the transaction index tail", "err", err)

+ }

+}

+

+// ReadFastTxLookupLimit retrieves the tx lookup limit used in fast sync.

+func ReadFastTxLookupLimit(db ethdb.KeyValueReader) *uint64 {

+ data, _ := db.Get(fastTxLookupLimitKey)

+ if len(data) != 8 {

+ return nil

+ }

+ number := binary.BigEndian.Uint64(data)

+ return &number

+}

+

+// WriteFastTxLookupLimit stores the txlookup limit used in fast sync into database.

+func WriteFastTxLookupLimit(db ethdb.KeyValueWriter, number uint64) {

+ if err := db.Put(fastTxLookupLimitKey, encodeBlockNumber(number)); err != nil {

+ log.Crit("Failed to store transaction lookup limit for fast sync", "err", err)

+ }

+}

+

+ // First try to look up the data in ancient database. Extra hash

+ // comparison is necessary since ancient database only maintains

+ // the canonical data.

+ if len(data) > 0 && crypto.Keccak256Hash(data) == hash {

+ return data

+ // Then try to look up the data in leveldb.

+ data, _ = db.Get(headerKey(number, hash))

+ if len(data) > 0 {

+ return data

+ }

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ data, _ = db.Ancient(freezerHeaderTable, number)

+ if len(data) > 0 && crypto.Keccak256Hash(data) == hash {

+ return data

+ }

+ return nil // Can't find the data anywhere.

+ // First try to look up the data in ancient database. Extra hash

+ // comparison is necessary since ancient database only maintains

+ // the canonical data.

+ data, _ := db.Ancient(freezerBodiesTable, number)

+ if len(data) > 0 {

+ h, _ := db.Ancient(freezerHashTable, number)

+ if common.BytesToHash(h) == hash {

+ return data

+ }

+ }

+ // Then try to look up the data in leveldb.

+ data, _ = db.Get(blockBodyKey(number, hash))

+ if len(data) > 0 {

+ return data

+ }

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ data, _ = db.Ancient(freezerBodiesTable, number)

+ if len(data) > 0 {

+ h, _ := db.Ancient(freezerHashTable, number)

+ if common.BytesToHash(h) == hash {

+ return data

+ }

+ }

+ return nil // Can't find the data anywhere.

+}

+

+// ReadCanonicalBodyRLP retrieves the block body (transactions and uncles) for the canonical

+// block at number, in RLP encoding.

+func ReadCanonicalBodyRLP(db ethdb.Reader, number uint64) rlp.RawValue {

+ // If it's an ancient one, we don't need the canonical hash

+ // Need to get the hash

+ data, _ = db.Get(blockBodyKey(number, ReadCanonicalHash(db, number)))

+ // First try to look up the data in ancient database. Extra hash

+ // comparison is necessary since ancient database only maintains

+ // the canonical data.

+ if len(data) > 0 {

+ h, _ := db.Ancient(freezerHashTable, number)

+ if common.BytesToHash(h) == hash {

+ return data

+ // Then try to look up the data in leveldb.

+ data, _ = db.Get(headerTDKey(number, hash))

+ if len(data) > 0 {

+ return data

+ }

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ data, _ = db.Ancient(freezerDifficultyTable, number)

+ if len(data) > 0 {

+ h, _ := db.Ancient(freezerHashTable, number)

+ if common.BytesToHash(h) == hash {

+ return data

+ }

+ }

+ return nil // Can't find the data anywhere.

+ // First try to look up the data in ancient database. Extra hash

+ // comparison is necessary since ancient database only maintains

+ // the canonical data.

+ if len(data) > 0 {

+ h, _ := db.Ancient(freezerHashTable, number)

+ if common.BytesToHash(h) == hash {

+ return data

+ // Then try to look up the data in leveldb.

+ data, _ = db.Get(blockReceiptsKey(number, hash))

+ if len(data) > 0 {

+ return data

+ }

+ // In the background freezer is moving data from leveldb to flatten files.

+ // So during the first check for ancient db, the data is not yet in there,

+ // but when we reach into leveldb, the data was already moved. That would

+ // result in a not found error.

+ data, _ = db.Ancient(freezerReceiptTable, number)

+ if len(data) > 0 {

+ h, _ := db.Ancient(freezerHashTable, number)

+ if common.BytesToHash(h) == hash {

+ return data

+ }

+ }

+ return nil // Can't find the data anywhere.

+ prev *stateObject

+ prevdestruct bool

+ account *common.Address

+ if !ch.prevdestruct && s.snap != nil {

+ delete(s.snapDestructs, ch.prev.addrHash)

+ }

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/crypto"

+ "github.com/ethereum/go-ethereum/metrics"

+ "github.com/ethereum/go-ethereum/rlp"

+ originStorage Storage // Storage cache of original entries to dedup rewrites, reset for every transaction

+ pendingStorage Storage // Storage entries that need to be flushed to disk, at the end of an entire block

+ dirtyStorage Storage // Storage entries that have been modified in the current transaction execution

+ fakeStorage Storage // Fake storage which constructed by caller for debugging purpose.

+ if data.Root == (common.Hash{}) {

+ data.Root = emptyRoot

+ }

+ db: db,

+ address: address,

+ addrHash: crypto.Keccak256Hash(address[:]),

+ data: data,

+ originStorage: make(Storage),

+ pendingStorage: make(Storage),

+ dirtyStorage: make(Storage),

+ // If we have a pending write or clean cached, return that

+ if value, pending := s.pendingStorage[key]; pending {

+ if value, cached := s.originStorage[key]; cached {

+ return value

+ // If no live objects are available, attempt to use snapshots

+ var (

+ enc []byte

+ err error

+ )

+ if s.db.snap != nil {

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.db.SnapshotStorageReads += time.Since(start) }(time.Now())

+ }

+ // If the object was destructed in *this* block (and potentially resurrected),

+ // the storage has been cleared out, and we should *not* consult the previous

+ // snapshot about any storage values. The only possible alternatives are:

+ // 1) resurrect happened, and new slot values were set -- those should

+ // have been handles via pendingStorage above.

+ // 2) we don't have new values, and can deliver empty response back

+ if _, destructed := s.db.snapDestructs[s.addrHash]; destructed {

+ return common.Hash{}

+ }

+ enc, err = s.db.snap.Storage(s.addrHash, crypto.Keccak256Hash(key.Bytes()))

+ }

+ // If snapshot unavailable or reading from it failed, load from the database

+ if s.db.snap == nil || err != nil {

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.db.StorageReads += time.Since(start) }(time.Now())

+ }

+ if enc, err = s.getTrie(db).TryGet(key.Bytes()); err != nil {

+ s.setError(err)

+ return common.Hash{}

+ }

+ var value common.Hash

+// finalise moves all dirty storage slots into the pending area to be hashed or

+// committed later. It is invoked at the end of every transaction.

+func (s *stateObject) finalise() {

+ for key, value := range s.dirtyStorage {

+ s.pendingStorage[key] = value

+ }

+ if len(s.dirtyStorage) > 0 {

+ s.dirtyStorage = make(Storage)

+ }

+}

+

+// It will return nil if the trie has not been loaded and no changes have been made

+ // Make sure all dirty slots are finalized into the pending storage area

+ s.finalise()

+ if len(s.pendingStorage) == 0 {

+ return s.trie

+ }

+ // Retrieve the snapshot storage map for the object

+ var storage map[common.Hash][]byte

+ if s.db.snap != nil {

+ // Retrieve the old storage map, if available, create a new one otherwise

+ storage = s.db.snapStorage[s.addrHash]

+ if storage == nil {

+ storage = make(map[common.Hash][]byte)

+ s.db.snapStorage[s.addrHash] = storage

+ }

+ }

+ // Insert all the pending updates into the trie

+ for key, value := range s.pendingStorage {

+ var v []byte

+ } else {

+ // Encoding []byte cannot fail, ok to ignore the error.

+ v, _ = rlp.EncodeToBytes(common.TrimLeftZeroes(value[:]))

+ s.setError(tr.TryUpdate(key[:], v))

+ }

+ // If state snapshotting is active, cache the data til commit

+ if storage != nil {

+ storage[crypto.Keccak256Hash(key[:])] = v // v will be nil if value is 0x00

+ }

+ if len(s.pendingStorage) > 0 {

+ s.pendingStorage = make(Storage)

+ // If nothing changed, don't bother with hashing anything

+ if s.updateTrie(db) == nil {

+ return

+ }

+ // If nothing changed, don't bother with hashing anything

+ if s.updateTrie(db) == nil {

+ return nil

+ }

+// AddBalance adds amount to s's balance.

+ // EIP161: We must check emptiness for the objects such that the account

+// SubBalance removes amount from s's balance.

+ stateObject.pendingStorage = s.pendingStorage.Copy()

+// CodeSize returns the size of the contract code associated with this object,

+// or zero if none. This method is an almost mirror of Code, but uses a cache

+// inside the database to avoid loading codes seen recently.

+func (s *stateObject) CodeSize(db Database) int {

+ if s.code != nil {

+ return len(s.code)

+ }

+ if bytes.Equal(s.CodeHash(), emptyCodeHash) {

+ return 0

+ }

+ size, err := db.ContractCodeSize(s.addrHash, common.BytesToHash(s.CodeHash()))

+ if err != nil {

+ s.setError(fmt.Errorf("can't load code size %x: %v", s.CodeHash(), err))

+ }

+ return size

+}

+

+ "github.com/ava-labs/coreth/core/rawdb"

+ "github.com/ava-labs/coreth/core/state/snapshot"

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/crypto"

+ "github.com/ethereum/go-ethereum/log"

+ "github.com/ethereum/go-ethereum/metrics"

+ "github.com/ethereum/go-ethereum/rlp"

+ "github.com/ethereum/go-ethereum/trie"

+// StateDB structs within the ethereum protocol are used to store anything

+ snaps *snapshot.Tree

+ snap snapshot.Snapshot

+ snapDestructs map[common.Hash]struct{}

+ snapAccounts map[common.Hash][]byte

+ snapStorage map[common.Hash]map[common.Hash][]byte

+

+ stateObjects map[common.Address]*stateObject

+ stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie

+ stateObjectsDirty map[common.Address]struct{} // State objects modified in the current execution

+ AccountReads time.Duration

+ AccountHashes time.Duration

+ AccountUpdates time.Duration

+ AccountCommits time.Duration

+ StorageReads time.Duration

+ StorageHashes time.Duration

+ StorageUpdates time.Duration

+ StorageCommits time.Duration

+ SnapshotAccountReads time.Duration

+ SnapshotStorageReads time.Duration

+ SnapshotCommits time.Duration

+}

+

+// New creates a new state from a given trie.

+func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) {

+ sdb := &StateDB{

+ db: db,

+ trie: tr,

+ snaps: snaps,

+ stateObjects: make(map[common.Address]*stateObject),

+ stateObjectsPending: make(map[common.Address]struct{}),

+ stateObjectsDirty: make(map[common.Address]struct{}),

+ logs: make(map[common.Hash][]*types.Log),

+ preimages: make(map[common.Hash][]byte),

+ journal: newJournal(),

+ }

+ if sdb.snaps != nil {

+ if sdb.snap = sdb.snaps.Snapshot(root); sdb.snap != nil {

+ sdb.snapDestructs = make(map[common.Hash]struct{})

+ sdb.snapAccounts = make(map[common.Hash][]byte)

+ sdb.snapStorage = make(map[common.Hash]map[common.Hash][]byte)

+ }

+ }

+ return sdb, nil

+func (s *StateDB) setError(err error) {

+ if s.dbErr == nil {

+ s.dbErr = err

+func (s *StateDB) Error() error {

+ return s.dbErr

+func (s *StateDB) Reset(root common.Hash) error {

+ tr, err := s.db.OpenTrie(root)

+ s.trie = tr

+ s.stateObjects = make(map[common.Address]*stateObject)

+ s.stateObjectsPending = make(map[common.Address]struct{})

+ s.stateObjectsDirty = make(map[common.Address]struct{})

+ s.thash = common.Hash{}

+ s.bhash = common.Hash{}

+ s.txIndex = 0

+ s.logs = make(map[common.Hash][]*types.Log)

+ s.logSize = 0

+ s.preimages = make(map[common.Hash][]byte)

+ s.clearJournalAndRefund()

+

+ if s.snaps != nil {

+ s.snapAccounts, s.snapDestructs, s.snapStorage = nil, nil, nil

+ if s.snap = s.snaps.Snapshot(root); s.snap != nil {

+ s.snapDestructs = make(map[common.Hash]struct{})

+ s.snapAccounts = make(map[common.Hash][]byte)

+ s.snapStorage = make(map[common.Hash]map[common.Hash][]byte)

+ }

+ }

+func (s *StateDB) AddLog(log *types.Log) {

+ s.journal.append(addLogChange{txhash: s.thash})

+ log.TxHash = s.thash

+ log.BlockHash = s.bhash

+ log.TxIndex = uint(s.txIndex)

+ log.Index = s.logSize

+ s.logs[s.thash] = append(s.logs[s.thash], log)

+ s.logSize++

+func (s *StateDB) GetLogs(hash common.Hash) []*types.Log {

+ return s.logs[hash]

+func (s *StateDB) Logs() []*types.Log {

+ for _, lgs := range s.logs {

+func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte) {

+ if _, ok := s.preimages[hash]; !ok {

+ s.journal.append(addPreimageChange{hash: hash})

+ s.preimages[hash] = pi

+func (s *StateDB) Preimages() map[common.Hash][]byte {

+ return s.preimages

+func (s *StateDB) AddRefund(gas uint64) {

+ s.journal.append(refundChange{prev: s.refund})

+ s.refund += gas

+func (s *StateDB) SubRefund(gas uint64) {

+ s.journal.append(refundChange{prev: s.refund})

+ if gas > s.refund {

+ panic(fmt.Sprintf("Refund counter below zero (gas: %d > refund: %d)", gas, s.refund))

+ s.refund -= gas

+func (s *StateDB) Exist(addr common.Address) bool {

+ return s.getStateObject(addr) != nil

+func (s *StateDB) Empty(addr common.Address) bool {

+ so := s.getStateObject(addr)

+// GetBalance retrieves the balance from the given address or 0 if object not found

+func (s *StateDB) GetBalance(addr common.Address) *big.Int {

+ stateObject := s.getStateObject(addr)

+func (s *StateDB) GetNonce(addr common.Address) uint64 {

+ stateObject := s.getStateObject(addr)

+func (s *StateDB) TxIndex() int {

+ return s.txIndex

+func (s *StateDB) BlockHash() common.Hash {

+ return s.bhash

+func (s *StateDB) GetCode(addr common.Address) []byte {

+ stateObject := s.getStateObject(addr)

+ return stateObject.Code(s.db)

+func (s *StateDB) GetCodeSize(addr common.Address) int {

+ stateObject := s.getStateObject(addr)

+ if stateObject != nil {

+ return stateObject.CodeSize(s.db)

+ return 0

+func (s *StateDB) GetCodeHash(addr common.Address) common.Hash {

+ stateObject := s.getStateObject(addr)

+func (s *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {

+ stateObject := s.getStateObject(addr)

+ return stateObject.GetState(s.db, hash)

+func (s *StateDB) GetProof(a common.Address) ([][]byte, error) {

+ err := s.trie.Prove(crypto.Keccak256(a.Bytes()), 0, &proof)

+// GetStorageProof returns the StorageProof for given key

+func (s *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {

+ trie := s.StorageTrie(a)

+func (s *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {

+ stateObject := s.getStateObject(addr)

+ return stateObject.GetCommittedState(s.db, hash)

+func (s *StateDB) Database() Database {

+ return s.db

+func (s *StateDB) StorageTrie(addr common.Address) Trie {

+ stateObject := s.getStateObject(addr)

+ cpy := stateObject.deepCopy(s)

+ cpy.updateTrie(s.db)

+ return cpy.getTrie(s.db)

+func (s *StateDB) HasSuicided(addr common.Address) bool {

+ stateObject := s.getStateObject(addr)

+func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) {

+ stateObject := s.GetOrNewStateObject(addr)

+func (s *StateDB) SubBalance(addr common.Address, amount *big.Int) {

+ stateObject := s.GetOrNewStateObject(addr)

+func (s *StateDB) SetBalance(addr common.Address, amount *big.Int) {

+ stateObject := s.GetOrNewStateObject(addr)

+func (s *StateDB) AddBalanceMultiCoin(addr common.Address, coinID common.Hash, amount *big.Int) {

+ stateObject := s.GetOrNewStateObject(addr)

+ stateObject.AddBalanceMultiCoin(coinID, amount, s.db)

+func (s *StateDB) SubBalanceMultiCoin(addr common.Address, coinID common.Hash, amount *big.Int) {

+ stateObject := s.GetOrNewStateObject(addr)

+ stateObject.SubBalanceMultiCoin(coinID, amount, s.db)

+func (s *StateDB) SetBalanceMultiCoin(addr common.Address, coinID common.Hash, amount *big.Int) {

+ stateObject := s.GetOrNewStateObject(addr)

+ stateObject.SetBalanceMultiCoin(coinID, amount, s.db)

+func (s *StateDB) SetNonce(addr common.Address, nonce uint64) {

+ stateObject := s.GetOrNewStateObject(addr)

+func (s *StateDB) SetCode(addr common.Address, code []byte) {

+ stateObject := s.GetOrNewStateObject(addr)

+func (s *StateDB) SetState(addr common.Address, key, value common.Hash) (res error) {

+ stateObject := s.GetOrNewStateObject(addr)

+ stateObject.SetState(s.db, key, value)

+func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common.Hash) {

+ stateObject := s.GetOrNewStateObject(addr)

+func (s *StateDB) Suicide(addr common.Address) bool {

+ stateObject := s.getStateObject(addr)

+ s.journal.append(suicideChange{

+func (s *StateDB) updateStateObject(obj *stateObject) {

+ addr := obj.Address()

+ data, err := rlp.EncodeToBytes(obj)

+ if err = s.trie.TryUpdate(addr[:], data); err != nil {

+ s.setError(fmt.Errorf("updateStateObject (%x) error: %v", addr[:], err))

+ }

+

+ // If state snapshotting is active, cache the data til commit. Note, this

+ // update mechanism is not symmetric to the deletion, because whereas it is

+ // enough to track account updates at commit time, deletions need tracking

+ // at transaction boundary level to ensure we capture state clearing.

+ if s.snap != nil {

+ s.snapAccounts[obj.addrHash] = snapshot.SlimAccountRLP(obj.data.Nonce, obj.data.Balance, obj.data.Root, obj.data.CodeHash)

+ }

+func (s *StateDB) deleteStateObject(obj *stateObject) {

+ addr := obj.Address()

+ if err := s.trie.TryDelete(addr[:]); err != nil {

+ s.setError(fmt.Errorf("deleteStateObject (%x) error: %v", addr[:], err))

+ }

+}

+// getStateObject retrieves a state object given by the address, returning nil if

+// the object is not found or was deleted in this execution context. If you need

+// to differentiate between non-existent/just-deleted, use getDeletedStateObject.

+func (s *StateDB) getStateObject(addr common.Address) *stateObject {

+ if obj := s.getDeletedStateObject(addr); obj != nil && !obj.deleted {

+ return obj

+ }

+ return nil

+// getDeletedStateObject is similar to getStateObject, but instead of returning

+// nil for a deleted state object, it returns the actual object with the deleted

+// flag set. This is needed by the state journal to revert to the correct s-

+// destructed object instead of wiping all knowledge about the state object.

+func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {

+ // Prefer live objects if any is available

+ // If no live objects are available, attempt to use snapshots

+ var (

+ data *Account

+ err error

+ )

+ if s.snap != nil {

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.SnapshotAccountReads += time.Since(start) }(time.Now())

+ }

+ var acc *snapshot.Account

+ if acc, err = s.snap.Account(crypto.Keccak256Hash(addr.Bytes())); err == nil {

+ if acc == nil {

+ return nil

+ }

+ data = &Account{

+ Nonce: acc.Nonce,

+ Balance: acc.Balance,

+ CodeHash: acc.CodeHash,

+ Root: common.BytesToHash(acc.Root),

+ }

+ if len(data.CodeHash) == 0 {

+ data.CodeHash = emptyCodeHash

+ }

+ if data.Root == (common.Hash{}) {

+ data.Root = emptyRoot

+ }

+ }

+ // If snapshot unavailable or reading from it failed, load from the database

+ if s.snap == nil || err != nil {

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now())

+ }

+ enc, err := s.trie.TryGet(addr.Bytes())

+ if err != nil {

+ s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %v", addr.Bytes(), err))

+ return nil

+ }

+ if len(enc) == 0 {

+ return nil

+ }

+ data = new(Account)

+ if err := rlp.DecodeBytes(enc, data); err != nil {

+ log.Error("Failed to decode state object", "addr", addr, "err", err)

+ return nil

+ }

+ obj := newObject(s, addr, *data)

+func (s *StateDB) setStateObject(object *stateObject) {

+ s.stateObjects[object.Address()] = object

+// GetOrNewStateObject retrieves a state object or create a new state object if nil.

+func (s *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {

+ stateObject := s.getStateObject(addr)

+ if stateObject == nil {

+ stateObject, _ = s.createObject(addr)

+func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {

+ prev = s.getDeletedStateObject(addr) // Note, prev might have been deleted, we need that!

+

+ var prevdestruct bool

+ if s.snap != nil && prev != nil {

+ _, prevdestruct = s.snapDestructs[prev.addrHash]

+ if !prevdestruct {

+ s.snapDestructs[prev.addrHash] = struct{}{}

+ }

+ }

+ newobj = newObject(s, addr, Account{})

+ s.journal.append(createObjectChange{account: &addr})

+ s.journal.append(resetObjectChange{prev: prev, prevdestruct: prevdestruct})

+ }

+ s.setStateObject(newobj)

+ if prev != nil && !prev.deleted {

+ return newobj, prev

+ return newobj, nil

+func (s *StateDB) CreateAccount(addr common.Address) {

+ newObj, prev := s.createObject(addr)

+func (s *StateDB) Copy() *StateDB {

+ db: s.db,

+ trie: s.db.CopyTrie(s.trie),

+ stateObjects: make(map[common.Address]*stateObject, len(s.journal.dirties)),

+ stateObjectsPending: make(map[common.Address]struct{}, len(s.stateObjectsPending)),

+ stateObjectsDirty: make(map[common.Address]struct{}, len(s.journal.dirties)),

+ refund: s.refund,

+ logs: make(map[common.Hash][]*types.Log, len(s.logs)),

+ logSize: s.logSize,

+ preimages: make(map[common.Hash][]byte, len(s.preimages)),

+ journal: newJournal(),

+ for addr := range s.journal.dirties {

+ if object, exist := s.stateObjects[addr]; exist {

+ // Even though the original object is dirty, we are not copying the journal,

+ // so we need to make sure that anyside effect the journal would have caused

+ // during a commit (or similar op) is already applied to the copy.

+

+ state.stateObjectsDirty[addr] = struct{}{} // Mark the copy dirty to force internal (code/state) commits

+ state.stateObjectsPending[addr] = struct{}{} // Mark the copy pending to force external (account) commits

+ for addr := range s.stateObjectsPending {

+ if _, exist := state.stateObjects[addr]; !exist {

+ state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state)

+ }

+ state.stateObjectsPending[addr] = struct{}{}

+ }

+ for addr := range s.stateObjectsDirty {

+ state.stateObjects[addr] = s.stateObjects[addr].deepCopy(state)

+ state.stateObjectsDirty[addr] = struct{}{}

+ for hash, logs := range s.logs {

+ for hash, preimage := range s.preimages {

+func (s *StateDB) Snapshot() int {

+ id := s.nextRevisionId

+ s.nextRevisionId++

+ s.validRevisions = append(s.validRevisions, revision{id, s.journal.length()})

+func (s *StateDB) RevertToSnapshot(revid int) {

+ idx := sort.Search(len(s.validRevisions), func(i int) bool {

+ return s.validRevisions[i].id >= revid

+ if idx == len(s.validRevisions) || s.validRevisions[idx].id != revid {

+ snapshot := s.validRevisions[idx].journalIndex

+ s.journal.revert(s, snapshot)

+ s.validRevisions = s.validRevisions[:idx]

+func (s *StateDB) GetRefund() uint64 {

+ return s.refund

+// Finalise finalises the state by removing the s destructed objects and clears

+// the journal as well as the refunds. Finalise, however, will not push any updates

+// into the tries just yet. Only IntermediateRoot or Commit will do that.

+ obj, exist := s.stateObjects[addr]

+ if obj.suicided || (deleteEmptyObjects && obj.empty()) {

+ obj.deleted = true

+

+ // If state snapshotting is active, also mark the destruction there.

+ // Note, we can't do this only at the end of a block because multiple

+ // transactions within the same block might self destruct and then

+ // ressurrect an account; but the snapshotter needs both events.

+ if s.snap != nil {

+ s.snapDestructs[obj.addrHash] = struct{}{} // We need to maintain account deletions explicitly (will remain set indefinitely)

+ delete(s.snapAccounts, obj.addrHash) // Clear out any previously updated account data (may be recreated via a ressurrect)

+ delete(s.snapStorage, obj.addrHash) // Clear out any previously updated storage data (may be recreated via a ressurrect)

+ }

+ obj.finalise()

+ s.stateObjectsPending[addr] = struct{}{}

+ // Finalise all the dirty storage states and write them into the tries

+ for addr := range s.stateObjectsPending {

+ obj := s.stateObjects[addr]

+ if obj.deleted {

+ s.deleteStateObject(obj)

+ } else {

+ obj.updateRoot(s.db)

+ s.updateStateObject(obj)

+ }

+ }

+ if len(s.stateObjectsPending) > 0 {

+ s.stateObjectsPending = make(map[common.Address]struct{})

+ }

+func (s *StateDB) Prepare(thash, bhash common.Hash, ti int) {

+ s.thash = thash

+ s.bhash = bhash

+ s.txIndex = ti

+ if len(s.journal.entries) > 0 {

+ s.journal = newJournal()

+ s.refund = 0

+ }

+ s.validRevisions = s.validRevisions[:0] // Snapshots can be created without journal entires

+func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) {

+ if s.dbErr != nil {

+ return common.Hash{}, fmt.Errorf("commit aborted due to earlier error: %v", s.dbErr)

+ // Finalize any pending changes and merge everything into the tries

+ s.IntermediateRoot(deleteEmptyObjects)

+

+ codeWriter := s.db.TrieDB().DiskDB().NewBatch()

+ for addr := range s.stateObjectsDirty {

+ if obj := s.stateObjects[addr]; !obj.deleted {

+ if obj.code != nil && obj.dirtyCode {

+ rawdb.WriteCode(codeWriter, common.BytesToHash(obj.CodeHash()), obj.code)

+ obj.dirtyCode = false

+ // Write any storage changes in the state object to its storage trie

+ if err := obj.CommitTrie(s.db); err != nil {

+ }

+ if len(s.stateObjectsDirty) > 0 {

+ s.stateObjectsDirty = make(map[common.Address]struct{})

+ }

+ if codeWriter.ValueSize() > 0 {

+ if err := codeWriter.Write(); err != nil {

+ log.Crit("Failed to commit dirty codes", "error", err)

+ }

+ var start time.Time

+ start = time.Now()

+ // The onleaf func is called _serially_, so we can reuse the same account

+ // for unmarshalling every time.

+ var account Account

+ root, err := s.trie.Commit(func(path []byte, leaf []byte, parent common.Hash) error {

+ if metrics.EnabledExpensive {

+ s.AccountCommits += time.Since(start)

+ }

+ // If snapshotting is enabled, update the snapshot tree with this new version

+ if s.snap != nil {

+ if metrics.EnabledExpensive {

+ defer func(start time.Time) { s.SnapshotCommits += time.Since(start) }(time.Now())

+ }

+ // Only update if there's a state transition (skip empty Clique blocks)

+ if parent := s.snap.Root(); parent != root {

+ if err := s.snaps.Update(root, parent, s.snapDestructs, s.snapAccounts, s.snapStorage); err != nil {

+ log.Warn("Failed to update snapshot tree", "from", parent, "to", root, "err", err)

+ }

+ if err := s.snaps.Cap(root, 127); err != nil { // Persistent layer is 128th, the last available trie

+ log.Warn("Failed to cap snapshot tree", "root", root, "layers", 127, "err", err)

+ }

+ }

+ s.snap, s.snapDestructs, s.snapAccounts, s.snapStorage = nil, nil, nil, nil

+ }

+ "github.com/ethereum/go-ethereum/common"

+ "github.com/ethereum/go-ethereum/crypto"

+ receipt, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, usedGas, cfg)

+func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) {

+ return nil, err

+ result, err := ApplyMessage(vmenv, msg, gp)

+ return nil, err

+ *usedGas += result.UsedGas

+ receipt := types.NewReceipt(root, result.Failed(), *usedGas)

+ receipt.GasUsed = result.UsedGas

+ return receipt, err