Refactored VM, VMState, and Block + new apply_transaction

docs/quickstart.rst

@@ -77,10 +77,11 @@ For example:
   highest_block_num = chain.get_canonical_head().block_number
 
   block1 = chain.get_canonical_block_by_number(1)
-  assert block1.number() == 1
+  assert block1.number == 1
 
   blockhash = block1.hash()
-  blockgas = block1.get_cumulative_gas_used()
+  vm = chain.get_vm()
+  blockgas = vm.get_cumulative_gas_used(block1)
 
 The methods available on the block are variable. They depend on what fork you're on.
 The mainnet follows "Frontier" rules at the beginning, then Homestead, and so on.

evm/chains/chain.py

@@ -179,7 +179,7 @@ def get_block_by_hash(self, block_hash):
 
     def get_block_by_header(self, block_header):
         vm = self.get_vm(block_header)
-        return vm.get_block_by_header(block_header)
+        return vm.get_block_by_header(block_header, self.chaindb)
 
     #
     # Chain Initialization
@@ -238,7 +238,8 @@ def apply_transaction(self, transaction):
         Apply the transaction to the current head block of the Chain.
         """
         vm = self.get_vm()
-        return vm.apply_transaction(transaction)
+        computation, _ = vm.apply_transaction(transaction)
+        return computation
 
     def import_block(self, block, perform_validation=True):
         """

evm/computation.py

@@ -71,12 +71,13 @@ class BaseComputation(object):
     logs = None
     accounts_to_delete = None
 
+    # VM configuration
     opcodes = None
-    precompiles = None
+    _precompiles = None
 
     logger = logging.getLogger('evm.vm.computation.Computation')
 
-    def __init__(self, vm_state, message, opcodes, precompiles):
+    def __init__(self, vm_state, message):
         self.vm_state = vm_state
         self.msg = message
 
@@ -91,9 +92,6 @@ def __init__(self, vm_state, message, opcodes, precompiles):
         code = message.code
         self.code = CodeStream(code)
 
-        self.opcodes = opcodes
-        self.precompiles = precompiles
-
     #
     # Convenience
     #
@@ -203,27 +201,21 @@ def apply_child_computation(self, child_msg):
         child_computation = self.generate_child_computation(
             self.vm_state,
             child_msg,
-            self.opcodes,
-            self.precompiles,
         )
         self.add_child_computation(child_computation)
         return child_computation
 
     @classmethod
-    def generate_child_computation(cls, vm_state, child_msg, opcodes, precompiles):
+    def generate_child_computation(cls, vm_state, child_msg):
         if child_msg.is_create:
             child_computation = cls(
                 vm_state,
                 child_msg,
-                opcodes,
-                precompiles,
             ).apply_create_message()
         else:
             child_computation = cls(
                 vm_state,
                 child_msg,
-                opcodes,
-                precompiles,
             ).apply_message()
         return child_computation
 
@@ -378,11 +370,11 @@ def apply_create_message(self):
         raise NotImplementedError("Must be implemented by subclasses")
 
     @classmethod
-    def apply_computation(cls, vm_state, message, opcodes, precompiles):
+    def apply_computation(cls, vm_state, message):
         """
         Perform the computation that would be triggered by the VM message.
         """
-        with cls(vm_state, message, opcodes, precompiles) as computation:
+        with cls(vm_state, message) as computation:
             # Early exit on pre-compiles
             if message.code_address in computation.precompiles:
                 computation.precompiles[message.code_address](computation)
@@ -407,6 +399,13 @@ def apply_computation(cls, vm_state, message, opcodes, precompiles):
     #
     # Opcode API
     #
+    @property
+    def precompiles(self):
+        if self._precompiles is None:
+            return dict()
+        else:
+            return self._precompiles
+
     def get_opcode_fn(self, opcodes, opcode):
         try:
             return opcodes[opcode]

evm/constants.py

@@ -162,3 +162,8 @@
 
 
 GAS_MOD_EXP_QUADRATIC_DENOMINATOR = 20
+
+#
+# BLOCKHASH opcode maximum depth
+#
+MAX_PREV_HEADER_DEPTH = 256

evm/db/backends/memory.py

@@ -6,8 +6,11 @@
 class MemoryDB(BaseDB):
     kv_store = None
 
-    def __init__(self):
-        self.kv_store = {}
+    def __init__(self, kv_store=None):
+        if kv_store is None:
+            self.kv_store = {}
+        else:
+            self.kv_store = kv_store
 
     def get(self, key):
         return self.kv_store[key]

evm/db/state.py

@@ -13,6 +13,9 @@
 from evm.db.immutable import (
     ImmutableDB,
 )
+from evm.db.tracked import (
+    TrackedDB,
+)
 from evm.rlp.accounts import (
     Account,
 )
@@ -21,7 +24,6 @@
     validate_uint256,
     validate_canonical_address,
 )
-
 from evm.utils.keccak import (
     keccak,
 )
@@ -46,9 +48,9 @@ class AccountStateDB:
 
     def __init__(self, db, root_hash=BLANK_ROOT_HASH, read_only=False):
         if read_only:
-            self.db = ImmutableDB(db)
+            self.db = TrackedDB(ImmutableDB(db))
         else:
-            self.db = db
+            self.db = TrackedDB(db)
         self._trie = HashTrie(HexaryTrie(self.db, root_hash))
 
     #

evm/db/tracked.py

@@ -0,0 +1,63 @@
+from .backends.base import BaseDB
+
+
+class AccessLogs(object):
+    reads = None
+    writes = None
+
+    def __init__(self, reads=None, writes=None):
+        if reads is None:
+            self.reads = {}
+        else:
+            self.reads = reads
+        if writes is None:
+            self.writes = {}
+        else:
+            self.writes = writes
+
+
+class TrackedDB(BaseDB):
+    """
+    The StateDB would be responsible for collecting all the touched keys.
+
+    access_logs.reads: the dict of read key-value
+    access_logs.writes: the dict of written key-value
+    """
+
+    wrapped_db = None
+    access_logs = None
+
+    def __init__(self, db):
+        self.wrapped_db = db
+        self.access_logs = AccessLogs()
+
+    def get(self, key):
+        """
+        Return the value of specific key and update read dict.
+        """
+        current_value = self.wrapped_db.get(key)
+        self.access_logs.reads[key] = current_value
+        return current_value
+
+    def set(self, key, value):
+        """
+        Set the key-value and update writes dict.
+        """
+        self.access_logs.writes[key] = value
+        return self.wrapped_db.set(key, value)
+
+    def exists(self, key):
+        """
+        Check if the key exsits.
+        """
+        result = self.wrapped_db.exists(key)
+        self.access_logs.reads[key] = self.wrapped_db.get(key) if result else None
+        return result
+
+    def delete(self, key):
+        """
+        Delete the key and update writes dict.
+        """
+        result = self.wrapped_db.delete(key)
+        self.access_logs.writes[key] = None
+        return result

evm/rlp/blocks.py

@@ -2,8 +2,6 @@
 
 
 class BaseBlock(rlp.Serializable):
-    db = None
-
     @classmethod
     def configure(cls, **overrides):
         class_name = cls.__name__
@@ -31,18 +29,12 @@ def get_transaction_class(cls):
         return cls.transaction_class
 
     @classmethod
-    def from_header(cls, header, db):
+    def from_header(cls, header, chaindb):
         """
         Returns the block denoted by the given block header.
         """
         raise NotImplementedError("Must be implemented by subclasses")
 
-    def get_parent_header(self):
-        """
-        Returns the header for the parent block.
-        """
-        raise NotImplementedError("Must be implemented by subclasses")
-
     @property
     def hash(self):
         raise NotImplementedError("Must be implemented by subclasses")
@@ -55,21 +47,6 @@ def number(self):
     def is_genesis(self):
         return self.number == 0
 
-    def validate(self):
-        pass
-
-    def add_transaction(self, transaction, computation):
-        """
-        Adds the given transaction to the current block.
-        """
-        raise NotImplementedError("Must be implemented by subclasses")
-
-    def mine(self, *args, **kwargs):
-        """
-        Mines the block.
-        """
-        raise NotImplementedError("Must be implemented by subclasses")
-
     def __repr__(self):
         return '<{class_name}(#{b})>'.format(
             class_name=self.__class__.__name__,

evm/utils/db.py

@@ -5,3 +5,17 @@ def make_block_number_to_hash_lookup_key(block_number):
 
 def make_block_hash_to_score_lookup_key(block_hash):
     return b'block-hash-to-score:%s' % block_hash
+
+
+def get_parent_header(block_header, db):
+    """
+    Returns the header for the parent block.
+    """
+    return db.get_block_header_by_hash(block_header.parent_hash)
+
+
+def get_block_header_by_hash(block_hash, db):
+    """
+    Returns the header for the parent block.
+    """
+    return db.get_block_header_by_hash(block_hash)

evm/utils/fixture_tests.py

@@ -657,7 +657,7 @@ def apply_fixture_block_to_chain(block_fixture, chain):
     else:
         block_class = chain.get_vm().get_block_class()
 
-    block = rlp.decode(block_fixture['rlp'], sedes=block_class, chaindb=chain.chaindb)
+    block = rlp.decode(block_fixture['rlp'], sedes=block_class)
 
     mined_block = chain.import_block(block)
 

evm/utils/headers.py

@@ -1,10 +1,16 @@
+import time
+
 from evm.constants import (
+    GENESIS_GAS_LIMIT,
     GAS_LIMIT_EMA_DENOMINATOR,
     GAS_LIMIT_ADJUSTMENT_FACTOR,
     GAS_LIMIT_MINIMUM,
     GAS_LIMIT_USAGE_ADJUSTMENT_NUMERATOR,
     GAS_LIMIT_USAGE_ADJUSTMENT_DENOMINATOR,
 )
+from evm.rlp.headers import (
+    BlockHeader,
+)
 
 
 def compute_gas_limit_bounds(parent):
@@ -65,3 +71,39 @@ def compute_gas_limit(parent_header, gas_limit_floor):
         return parent_header.gas_limit + decay
     else:
         return gas_limit
+
+
+def generate_header_from_parent_header(
+        compute_difficulty_fn,
+        parent_header,
+        coinbase,
+        timestamp=None,
+        extra_data=b''):
+    """
+    Generate BlockHeader from state_root and parent_header
+    """
+    if timestamp is None:
+        timestamp = max(int(time.time()), parent_header.timestamp + 1)
+    elif timestamp <= parent_header.timestamp:
+        raise ValueError(
+            "header.timestamp ({}) should be higher than"
+            "parent_header.timestamp ({})".format(
+                timestamp,
+                parent_header.timestamp,
+            )
+        )
+    header = BlockHeader(
+        difficulty=compute_difficulty_fn(parent_header, timestamp),
+        block_number=(parent_header.block_number + 1),
+        gas_limit=compute_gas_limit(
+            parent_header,
+            gas_limit_floor=GENESIS_GAS_LIMIT,
+        ),
+        timestamp=timestamp,
+        parent_hash=parent_header.hash,
+        state_root=parent_header.state_root,
+        coinbase=coinbase,
+        extra_data=extra_data,
+    )
+
+    return header

evm/utils/state.py

@@ -1,6 +1,13 @@
 from eth_utils import (
     to_tuple,
 )
+import rlp
+from trie import (
+    HexaryTrie,
+)
+
+from evm.db.backends.memory import MemoryDB
+from evm.db.chain import BaseChainDB
 
 
 @to_tuple
@@ -30,3 +37,16 @@ def diff_state_db(expected_state, state_db):
                     actual_storage_value,
                     expected_storage_value,
                 )
+
+
+# Make the root of a receipt tree
+def make_trie_root_and_nodes(transactions, trie_class=HexaryTrie):
+    chaindb = BaseChainDB(MemoryDB())
+    db = chaindb.db
+    transaction_db = trie_class(db)
+
+    for index, transaction in enumerate(transactions):
+        index_key = rlp.encode(index, sedes=rlp.sedes.big_endian_int)
+        transaction_db[index_key] = rlp.encode(transaction)
+
+    return transaction_db.root_hash, transaction_db.db.wrapped_db.kv_store