nimbus-eth1/nimbus/vm_state.nim

193 lines
6.8 KiB
Nim

# Nimbus
# Copyright (c) 2018 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed except according to those terms.
import
macros, strformat, tables, sets,
eth/common, eth/trie/db,
./constants, ./errors, ./transaction, ./db/[db_chain, state_db],
./utils, json, vm_types, vm/transaction_tracer
proc newAccessLogs*: AccessLogs =
AccessLogs(reads: initTable[string, string](), writes: initTable[string, string]())
proc update*[K, V](t: var Table[K, V], elements: Table[K, V]) =
for k, v in elements:
t[k] = v
proc `$`*(vmState: BaseVMState): string =
if vmState.isNil:
result = "nil"
else:
result = &"VMState {vmState.name}:\n header: {vmState.blockHeader}\n chaindb: {vmState.chaindb}"
proc init*(self: BaseVMState, prevStateRoot: Hash256, header: BlockHeader,
chainDB: BaseChainDB, tracerFlags: set[TracerFlags] = {}) =
self.prevHeaders = @[]
self.name = "BaseVM"
self.accessLogs = newAccessLogs()
self.blockHeader = header
self.chaindb = chainDB
self.tracer.initTracer(tracerFlags)
self.tracingEnabled = TracerFlags.EnableTracing in tracerFlags
self.logEntries = @[]
self.blockHeader.stateRoot = prevStateRoot
self.accountDb = newAccountStateDB(chainDB.db, prevStateRoot, chainDB.pruneTrie)
proc newBaseVMState*(prevStateRoot: Hash256, header: BlockHeader,
chainDB: BaseChainDB, tracerFlags: set[TracerFlags] = {}): BaseVMState =
new result
result.init(prevStateRoot, header, chainDB, tracerFlags)
proc stateRoot*(vmState: BaseVMState): Hash256 =
vmState.blockHeader.stateRoot
method blockhash*(vmState: BaseVMState): Hash256 {.base, gcsafe.} =
vmState.blockHeader.hash
method coinbase*(vmState: BaseVMState): EthAddress {.base, gcsafe.} =
vmState.blockHeader.coinbase
method timestamp*(vmState: BaseVMState): EthTime {.base, gcsafe.} =
vmState.blockHeader.timestamp
method blockNumber*(vmState: BaseVMState): BlockNumber {.base, gcsafe.} =
# it should return current block number
# and not head.blockNumber
vmState.blockHeader.blockNumber
method difficulty*(vmState: BaseVMState): UInt256 {.base, gcsafe.} =
vmState.blockHeader.difficulty
method gasLimit*(vmState: BaseVMState): GasInt {.base, gcsafe.} =
vmState.blockHeader.gasLimit
method getAncestorHash*(vmState: BaseVMState, blockNumber: BlockNumber): Hash256 {.base, gcsafe.} =
var ancestorDepth = vmState.blockHeader.blockNumber - blockNumber - 1
if ancestorDepth >= constants.MAX_PREV_HEADER_DEPTH or ancestorDepth < 0:
return
result = vmState.chainDB.getBlockHash(blockNumber)
#TODO: should we use deque here?
# someday we may revive this code when
# we already have working miner
when false:
let idx = ancestorDepth.toInt
if idx >= vmState.prevHeaders.len:
return
var header = vmState.prevHeaders[idx]
result = header.hash
when false:
# this was an older version of `mutateStateDB`, kept here for reference
# until `mutateStateDB` is fully implemented.
macro db*(vmState: untyped, readOnly: bool, handler: untyped): untyped =
# vm.state.db:
# setupStateDB(fixture{"pre"}, stateDb)
# code = db.getCode(fixture{"exec"}{"address"}.getStr)
let db = ident("db")
result = quote:
block:
var `db` = `vmState`.chaindb.getStateDB(`vmState`.blockHeader.stateRoot, `readOnly`)
`handler`
if `readOnly`:
# This acts as a secondary check that no mutation took place for
# read_only databases.
assert `db`.rootHash == `vmState`.blockHeader.stateRoot
elif `vmState`.blockHeader.stateRoot != `db`.rootHash:
`vmState`.blockHeader.stateRoot = `db`.rootHash
# TODO
# `vmState`.accessLogs.reads.update(`db`.db.accessLogs.reads)
# `vmState`.accessLogs.writes.update(`db`.db.accessLogs.writes)
# remove the reference to the underlying `db` object to ensure that no
# further modifications can occur using the `State` object after
# leaving the context.
# TODO `db`.db = nil
# state._trie = None
proc getStateDb*(vmState: BaseVMState; stateRoot: Hash256): AccountStateDB =
# TODO: use AccountStateDB revert/commit after JournalDB implemented
vmState.accountDb.rootHash = stateRoot
vmState.accountDb
proc readOnlyStateDB*(vmState: BaseVMState): ReadOnlyStateDB {.inline.} =
ReadOnlyStateDB(vmState.accountDb)
template mutateStateDB*(vmState: BaseVMState, body: untyped) =
# This should provide more clever change handling in the future
# TODO: use AccountStateDB revert/commit after JournalDB implemented
block:
let initialStateRoot = vmState.blockHeader.stateRoot
var db {.inject.} = vmState.getStateDB(initialStateRoot)
body
let finalStateRoot = db.rootHash
if finalStateRoot != initialStateRoot:
vmState.blockHeader.stateRoot = finalStateRoot
export DbTransaction, commit, rollback, dispose, safeDispose
type
Snapshot* = object
transaction: DbTransaction
intermediateRoot: Hash256
vmState: BaseVMState
proc snapshot*(vmState: BaseVMState): Snapshot =
# TODO: use AccountStateDB revert/commit after JournalDB implemented
result.transaction = vmState.chaindb.db.beginTransaction()
result.intermediateRoot = vmState.accountDb.rootHash
vmState.blockHeader.stateRoot = vmState.accountDb.rootHash
result.vmState = vmState
proc revert*(s: var Snapshot) =
s.transaction.rollback()
s.vmState.accountDb.rootHash = s.intermediateRoot
s.vmState.blockHeader.stateRoot = s.intermediateRoot
proc commit*(s: var Snapshot) =
s.transaction.commit()
s.vmState.accountDb.rootHash = s.vmState.blockHeader.stateRoot
proc dispose*(s: var Snapshot) {.inline.} =
s.transaction.dispose()
proc getTracingResult*(vmState: BaseVMState): JsonNode =
assert(vmState.tracingEnabled)
vmState.tracer.trace
proc addLogs*(vmState: BaseVMState, logs: seq[Log]) =
shallowCopy(vmState.logEntries, logs)
proc getAndClearLogEntries*(vmState: BaseVMState): seq[Log] =
shallowCopy(result, vmState.logEntries)
vmState.logEntries = @[]
proc enableTracing*(vmState: BaseVMState) =
vmState.tracingEnabled = true
proc disableTracing*(vmState: BaseVMState) =
vmState.tracingEnabled = false
iterator tracedAccounts*(vmState: BaseVMState): EthAddress =
for acc in vmState.tracer.accounts:
yield acc
iterator tracedAccountsPairs*(vmState: BaseVMState): (int, EthAddress) =
var idx = 0
for acc in vmState.tracer.accounts:
yield (idx, acc)
inc idx
proc removeTracedAccounts*(vmState: BaseVMState, accounts: varargs[EthAddress]) =
for acc in accounts:
vmState.tracer.accounts.excl acc