Add Type Hinting for eth.vm.forks

Author: Bhargavasomu

eth/vm/forks/byzantium/__init__.py

@@ -15,12 +15,15 @@
     MAX_UNCLE_DEPTH,
 )
 from eth.rlp.blocks import BaseBlock  # noqa: F401
+from eth.rlp.headers import BlockHeader
 from eth.rlp.receipts import Receipt
+from eth.rlp.transactions import BaseTransaction
 from eth.validation import (
     validate_lte,
 )
 from eth.vm.forks.spurious_dragon import SpuriousDragonVM
 from eth.vm.forks.frontier import make_frontier_receipt
+from eth.vm.computation import BaseComputation
 from eth.vm.state import BaseState  # noqa: F401
 
 from .blocks import ByzantiumBlock
@@ -37,7 +40,10 @@
 from .state import ByzantiumState
 
 
-def make_byzantium_receipt(base_header, transaction, computation, state):
+def make_byzantium_receipt(base_header: BlockHeader,
+                           transaction: BaseTransaction,
+                           computation: BaseComputation,
+                           state: BaseState) -> Receipt:
     frontier_receipt = make_frontier_receipt(base_header, transaction, computation, state)
 
     if computation.is_error:
@@ -49,7 +55,7 @@ def make_byzantium_receipt(base_header, transaction, computation, state):
 
 
 @curry
-def get_uncle_reward(block_reward, block_number, uncle):
+def get_uncle_reward(block_reward: int, block_number: int, uncle: BaseBlock) -> int:
     block_number_delta = block_number - uncle.block_number
     validate_lte(block_number_delta, MAX_UNCLE_DEPTH)
     return (8 - block_number_delta) * block_reward // 8
@@ -70,10 +76,10 @@ class ByzantiumVM(SpuriousDragonVM):
     _state_class = ByzantiumState  # type: Type[BaseState]
 
     # Methods
-    create_header_from_parent = staticmethod(create_byzantium_header_from_parent)
-    compute_difficulty = staticmethod(compute_byzantium_difficulty)
+    create_header_from_parent = staticmethod(create_byzantium_header_from_parent)   # type: ignore
+    compute_difficulty = staticmethod(compute_byzantium_difficulty)     # type: ignore
     configure_header = configure_byzantium_header
-    make_receipt = staticmethod(make_byzantium_receipt)
+    make_receipt = staticmethod(make_byzantium_receipt)     # type: ignore
     # Separated into two steps due to mypy bug of staticmethod.
     # https://github.com/python/mypy/issues/5530
     get_uncle_reward = get_uncle_reward(EIP649_BLOCK_REWARD)
@@ -93,5 +99,5 @@ def validate_receipt(cls, receipt: Receipt) -> None:
             )
 
     @staticmethod
-    def get_block_reward():
+    def get_block_reward() -> int:
         return EIP649_BLOCK_REWARD

eth/vm/forks/byzantium/opcodes.py

@@ -3,13 +3,19 @@
 
 from cytoolz import merge
 
+from typing import (
+    Any,
+    Callable,
+)
+
 from eth import constants
 
 from eth.exceptions import (
     WriteProtection,
 )
 from eth.vm import mnemonics
 from eth.vm import opcode_values
+from eth.vm.computation import BaseComputation
 from eth.vm.forks.tangerine_whistle.constants import (
     GAS_CALL_EIP150,
     GAS_SELFDESTRUCT_EIP150
@@ -26,9 +32,9 @@
 from eth.vm.forks.spurious_dragon.opcodes import SPURIOUS_DRAGON_OPCODES
 
 
-def ensure_no_static(opcode_fn):
+def ensure_no_static(opcode_fn: Callable[..., Any]) -> Callable[..., Any]:
     @functools.wraps(opcode_fn)
-    def inner(computation):
+    def inner(computation: BaseComputation) -> Callable[..., Any]:
         if computation.msg.is_static:
             raise WriteProtection("Cannot modify state while inside of a STATICCALL context")
         return opcode_fn(computation)

eth/vm/forks/byzantium/transactions.py

@@ -1,21 +1,38 @@
-from eth.vm.forks.spurious_dragon.transactions import (
-    SpuriousDragonTransaction,
-    SpuriousDragonUnsignedTransaction,
+from eth_keys.datatypes import PrivateKey
+from eth_typing import Address
+
+from eth.rlp.transactions import (
+    BaseTransaction,
+    BaseUnsignedTransaction,
 )
 
 from eth.utils.transactions import (
     create_transaction_signature,
 )
 
+from eth.vm.forks.spurious_dragon.transactions import (
+    SpuriousDragonTransaction,
+    SpuriousDragonUnsignedTransaction,
+)
+
 
 class ByzantiumTransaction(SpuriousDragonTransaction):
     @classmethod
-    def create_unsigned_transaction(cls, *, nonce, gas_price, gas, to, value, data):
+    def create_unsigned_transaction(cls,                 # type: ignore
+                                    *,
+                                    nonce: int,
+                                    gas_price: int,
+                                    gas: int,
+                                    to: Address,
+                                    value: int,
+                                    data: bytes) -> BaseTransaction:
         return ByzantiumUnsignedTransaction(nonce, gas_price, gas, to, value, data)
 
 
 class ByzantiumUnsignedTransaction(SpuriousDragonUnsignedTransaction):
-    def as_signed_transaction(self, private_key, chain_id=None):
+    def as_signed_transaction(self,                          # type: ignore
+                              private_key: PrivateKey,
+                              chain_id: int=None) -> BaseUnsignedTransaction:
         v, r, s = create_transaction_signature(self, private_key, chain_id=chain_id)
         return ByzantiumTransaction(
             nonce=self.nonce,

eth/vm/forks/constantinople/__init__.py

@@ -28,11 +28,11 @@ class ConstantinopleVM(ByzantiumVM):
     _state_class = ConstantinopleState  # type: Type[BaseState]
 
     # Methods
-    create_header_from_parent = staticmethod(create_constantinople_header_from_parent)
-    compute_difficulty = staticmethod(compute_constantinople_difficulty)
+    create_header_from_parent = staticmethod(create_constantinople_header_from_parent)  # type: ignore  # noqa: E501
+    compute_difficulty = staticmethod(compute_constantinople_difficulty)    # type: ignore
     configure_header = configure_constantinople_header
     get_uncle_reward = staticmethod(get_uncle_reward(EIP1234_BLOCK_REWARD))
 
     @staticmethod
-    def get_block_reward():
+    def get_block_reward() -> int:
         return EIP1234_BLOCK_REWARD

eth/vm/forks/constantinople/storage.py

@@ -1,6 +1,8 @@
 from eth.constants import (
     UINT256
 )
+
+from eth.vm.computation import BaseComputation
 from eth.vm.forks.constantinople import (
     constants
 )
@@ -10,7 +12,7 @@
 )
 
 
-def sstore_eip1283(computation):
+def sstore_eip1283(computation: BaseComputation) -> None:
     slot, value = computation.stack_pop(num_items=2, type_hint=UINT256)
 
     current_value = computation.state.account_db.get_storage(

eth/vm/forks/constantinople/transactions.py

@@ -1,3 +1,11 @@
+from eth_keys.datatypes import PrivateKey
+from eth_typing import Address
+
+from eth.rlp.transactions import (
+    BaseTransaction,
+    BaseUnsignedTransaction,
+)
+
 from eth.vm.forks.byzantium.transactions import (
     ByzantiumTransaction,
     ByzantiumUnsignedTransaction,
@@ -10,12 +18,21 @@
 
 class ConstantinopleTransaction(ByzantiumTransaction):
     @classmethod
-    def create_unsigned_transaction(cls, *, nonce, gas_price, gas, to, value, data):
+    def create_unsigned_transaction(cls,             # type: ignore
+                                    *,
+                                    nonce: int,
+                                    gas_price: int,
+                                    gas: int,
+                                    to: Address,
+                                    value: int,
+                                    data: bytes) -> BaseTransaction:
         return ConstantinopleUnsignedTransaction(nonce, gas_price, gas, to, value, data)
 
 
 class ConstantinopleUnsignedTransaction(ByzantiumUnsignedTransaction):
-    def as_signed_transaction(self, private_key, chain_id=None):
+    def as_signed_transaction(self,                         # type: ignore
+                              private_key: PrivateKey,
+                              chain_id: int=None) -> BaseUnsignedTransaction:
         v, r, s = create_transaction_signature(self, private_key, chain_id=chain_id)
         return ConstantinopleTransaction(
             nonce=self.nonce,

eth/vm/forks/frontier/__init__.py

@@ -1,19 +1,19 @@
 from typing import Type  # noqa: F401
-from eth.rlp.blocks import BaseBlock  # noqa: F401
-from eth.vm.state import BaseState  # noqa: F401
-
 
 from eth.constants import (
     BLOCK_REWARD,
     UNCLE_DEPTH_PENALTY_FACTOR,
 )
+
+from eth.rlp.blocks import BaseBlock  # noqa: F401
+from eth.rlp.headers import BlockHeader
+from eth.rlp.logs import Log
+from eth.rlp.receipts import Receipt
+from eth.rlp.transactions import BaseTransaction
+
 from eth.vm.base import VM
-from eth.rlp.receipts import (
-    Receipt,
-)
-from eth.rlp.logs import (
-    Log,
-)
+from eth.vm.computation import BaseComputation
+from eth.vm.state import BaseState  # noqa: F401
 
 from .blocks import FrontierBlock
 from .state import FrontierState
@@ -25,7 +25,10 @@
 from .validation import validate_frontier_transaction_against_header
 
 
-def make_frontier_receipt(base_header, transaction, computation, state):
+def make_frontier_receipt(base_header: BlockHeader,
+                          transaction: BaseTransaction,
+                          computation: BaseComputation,
+                          state: BaseState) -> Receipt:
     # Reusable for other forks
 
     logs = [
@@ -62,22 +65,22 @@ class FrontierVM(VM):
     _state_class = FrontierState  # type: Type[BaseState]
 
     # methods
-    create_header_from_parent = staticmethod(create_frontier_header_from_parent)
-    compute_difficulty = staticmethod(compute_frontier_difficulty)
+    create_header_from_parent = staticmethod(create_frontier_header_from_parent)    # type: ignore
+    compute_difficulty = staticmethod(compute_frontier_difficulty)      # type: ignore
     configure_header = configure_frontier_header
-    make_receipt = staticmethod(make_frontier_receipt)
+    make_receipt = staticmethod(make_frontier_receipt)      # type: ignore
     validate_transaction_against_header = validate_frontier_transaction_against_header
 
     @staticmethod
-    def get_block_reward():
+    def get_block_reward() -> int:
         return BLOCK_REWARD
 
     @staticmethod
-    def get_uncle_reward(block_number, uncle):
+    def get_uncle_reward(block_number: int, uncle: BaseBlock) -> int:
         return BLOCK_REWARD * (
             UNCLE_DEPTH_PENALTY_FACTOR + uncle.block_number - block_number
         ) // UNCLE_DEPTH_PENALTY_FACTOR
 
     @classmethod
-    def get_nephew_reward(cls):
+    def get_nephew_reward(cls) -> int:
         return cls.get_block_reward() // 32

eth/vm/forks/frontier/blocks.py

@@ -1,5 +1,7 @@
 from typing import (  # noqa: F401
-    List
+    Iterable,
+    List,
+    Type,
 )
 
 import rlp
@@ -11,20 +13,32 @@
     BloomFilter,
 )
 
+from eth_typing import (
+    Hash32,
+)
+
 from eth_hash.auto import keccak
 
 from eth.constants import (
     EMPTY_UNCLE_HASH,
 )
-from eth.rlp.receipts import (
-    Receipt,
+
+from eth.db.chain import (
+    BaseChainDB,
 )
+
 from eth.rlp.blocks import (
     BaseBlock,
 )
 from eth.rlp.headers import (
     BlockHeader,
 )
+from eth.rlp.receipts import (
+    Receipt,
+)
+from eth.rlp.transactions import (
+    BaseTransaction,
+)
 
 from .transactions import (
     FrontierTransaction,
@@ -41,7 +55,10 @@ class FrontierBlock(BaseBlock):
 
     bloom_filter = None
 
-    def __init__(self, header, transactions=None, uncles=None):
+    def __init__(self,
+                 header: BlockHeader,
+                 transactions: Iterable[BaseTransaction]=None,
+                 uncles: Iterable[BlockHeader]=None) -> None:
         if transactions is None:
             transactions = []
         if uncles is None:
@@ -60,36 +77,36 @@ def __init__(self, header, transactions=None, uncles=None):
     # Helpers
     #
     @property
-    def number(self):
+    def number(self) -> int:
         return self.header.block_number
 
     @property
-    def hash(self):
+    def hash(self) -> Hash32:
         return self.header.hash
 
     #
     # Transaction class for this block class
     #
     @classmethod
-    def get_transaction_class(cls):
+    def get_transaction_class(cls) -> Type[BaseTransaction]:
         return cls.transaction_class
 
     #
     # Receipts API
     #
-    def get_receipts(self, chaindb):
+    def get_receipts(self, chaindb: BaseChainDB) -> Iterable[Receipt]:
         return chaindb.get_receipts(self.header, Receipt)
 
     #
     # Header API
     #
     @classmethod
-    def from_header(cls, header, chaindb):
+    def from_header(cls, header: BlockHeader, chaindb: BaseChainDB) -> BaseBlock:
         """
         Returns the block denoted by the given block header.
         """
         if header.uncles_hash == EMPTY_UNCLE_HASH:
-            uncles = []  # type: List[bytes]
+            uncles = []  # type: List[BlockHeader]
         else:
             uncles = chaindb.get_block_uncles(header.uncles_hash)
 
@@ -104,7 +121,7 @@ def from_header(cls, header, chaindb):
     #
     # Execution API
     #
-    def add_uncle(self, uncle):
+    def add_uncle(self, uncle: BlockHeader) -> "FrontierBlock":
         self.uncles.append(uncle)
         self.header.uncles_hash = keccak(rlp.encode(self.uncles))
         return self