Lazily evaluate vm.previous_hashes

Author: Bhargavasomu

eth/rlp/headers.py

@@ -1,7 +1,7 @@
 import time
 from typing import (
+    Iterable,
     Optional,
-    Tuple,
     Union,
     overload,
 )
@@ -203,7 +203,7 @@ def from_parent(cls,
         return header
 
     def create_execution_context(
-            self, prev_hashes: Tuple[Hash32, ...]) -> ExecutionContext:
+            self, prev_hashes: Iterable[Hash32]) -> ExecutionContext:
 
         return ExecutionContext(
             coinbase=self.coinbase,

eth/vm/base.py

@@ -4,7 +4,7 @@
     abstractmethod,
 )
 import contextlib
-import functools
+import itertools
 import logging
 from typing import (
     Any,
@@ -28,7 +28,6 @@
 )
 
 from eth_utils import (
-    to_tuple,
     ValidationError,
 )
 
@@ -258,7 +257,6 @@ def get_nephew_reward(cls) -> int:
 
     @classmethod
     @abstractmethod
-    @to_tuple
     def get_prev_hashes(cls,
                         last_block_hash: Hash32,
                         chaindb: BaseChainDB) -> Optional[Iterable[Hash32]]:
@@ -691,8 +689,6 @@ def get_block_class(cls) -> Type[BaseBlock]:
             return cls.block_class
 
     @classmethod
-    @functools.lru_cache(maxsize=32)
-    @to_tuple
     def get_prev_hashes(cls,
                         last_block_hash: Hash32,
                         chaindb: BaseChainDB) -> Optional[Iterable[Hash32]]:
@@ -709,7 +705,7 @@ def get_prev_hashes(cls,
                 break
 
     @property
-    def previous_hashes(self) -> Optional[Tuple[Hash32, ...]]:
+    def previous_hashes(self) -> Optional[Iterable[Hash32]]:
         """
         Convenience API for accessing the previous 255 block hashes.
         """
@@ -919,7 +915,7 @@ def get_state_class(cls) -> Type[BaseState]:
     def state_in_temp_block(self) -> Iterator[BaseState]:
         header = self.block.header
         temp_block = self.generate_block_from_parent_header_and_coinbase(header, header.coinbase)
-        prev_hashes = (header.hash, ) + self.previous_hashes
+        prev_hashes = itertools.chain((header.hash, ), self.previous_hashes)
 
         state = self.get_state_class()(
             db=self.chaindb.db,

eth/vm/execution_context.py

@@ -1,4 +1,6 @@
-from typing import Tuple
+from typing import (
+    Iterable,
+)
 
 from eth_typing import (
     Address,
@@ -22,7 +24,7 @@ def __init__(
             block_number: int,
             difficulty: int,
             gas_limit: int,
-            prev_hashes: Tuple[Hash32, ...]) -> None:
+            prev_hashes: Iterable[Hash32]) -> None:
         self._coinbase = coinbase
         self._timestamp = timestamp
         self._block_number = block_number
@@ -51,5 +53,5 @@ def gas_limit(self) -> int:
         return self._gas_limit
 
     @property
-    def prev_hashes(self) -> Tuple[Hash32, ...]:
+    def prev_hashes(self) -> Iterable[Hash32]:
         return self._prev_hashes

eth/vm/state.py

@@ -3,6 +3,7 @@
     abstractmethod
 )
 import contextlib
+import itertools
 import logging
 from typing import (  # noqa: F401
     cast,
@@ -84,11 +85,14 @@ class for vm execution.
     transaction_context_class = None  # type: Type[BaseTransactionContext]
     account_db_class = None  # type: Type[BaseAccountDB]
     transaction_executor = None  # type: Type[BaseTransactionExecutor]
+    prev_hashes_generator_backup = None
 
     def __init__(self, db: BaseDB, execution_context: ExecutionContext, state_root: bytes) -> None:
         self._db = db
         self.execution_context = execution_context
         self.account_db = self.get_account_db_class()(self._db, state_root)
+        if execution_context:
+            self.prev_hashes_generator_backup = execution_context.prev_hashes
 
     #
     # Logging
@@ -197,16 +201,34 @@ def get_ancestor_hash(self, block_number: int) -> Hash32:
         Return the empty bytestring ``b''`` if the block number is outside of the
         range of available block numbers (typically the last 255 blocks).
         """
+        # Create a copy of the generator so that traversing it doesn't change the
+        # original generator
+        self.prev_hashes_generator_backup, temp_prev_hashes_generator = itertools.tee(
+            self.prev_hashes_generator_backup
+        )
+
         ancestor_depth = self.block_number - block_number - 1
         is_ancestor_depth_out_of_range = (
             ancestor_depth >= MAX_PREV_HEADER_DEPTH or
             ancestor_depth < 0 or
-            ancestor_depth >= len(self.execution_context.prev_hashes)
+            block_number < 0
         )
         if is_ancestor_depth_out_of_range:
             return Hash32(b'')
-        ancestor_hash = self.execution_context.prev_hashes[ancestor_depth]
-        return ancestor_hash
+
+        current_ancestor_depth = 0
+        current_ancestor_hash = None
+        while True:
+            try:
+                current_ancestor_hash = next(temp_prev_hashes_generator)
+            except StopIteration:
+                # Ancestor with specified depth not present
+                return Hash32(b'')
+            if current_ancestor_depth == ancestor_depth:
+                return current_ancestor_hash
+            current_ancestor_depth += 1
+
+        raise Exception("Invariant: unreachable code path")
 
     #
     # Computation