Add new mysterious Petersburg fork

Author: cburgdorf

eth/vm/forks/petersburg/__init__.py

@@ -0,0 +1,38 @@
+from typing import (  # noqa: F401
+    Type,
+)
+
+from eth.rlp.blocks import BaseBlock  # noqa: F401
+from eth.vm.forks.byzantium import (
+    ByzantiumVM,
+    get_uncle_reward,
+)
+from eth.vm.state import BaseState  # noqa: F401
+
+from .blocks import PetersburgBlock
+from .constants import EIP1234_BLOCK_REWARD
+from .headers import (
+    compute_petersburg_difficulty,
+    configure_petersburg_header,
+    create_petersburg_header_from_parent,
+)
+from .state import PetersburgState
+
+
+class PetersburgVM(ByzantiumVM):
+    # fork name
+    fork = 'petersburg'
+
+    # classes
+    block_class = PetersburgBlock  # type: Type[BaseBlock]
+    _state_class = PetersburgState  # type: Type[BaseState]
+
+    # Methods
+    create_header_from_parent = staticmethod(create_petersburg_header_from_parent)  # type: ignore  # noqa: E501
+    compute_difficulty = staticmethod(compute_petersburg_difficulty)    # type: ignore
+    configure_header = configure_petersburg_header
+    get_uncle_reward = staticmethod(get_uncle_reward(EIP1234_BLOCK_REWARD))
+
+    @staticmethod
+    def get_block_reward() -> int:
+        return EIP1234_BLOCK_REWARD

eth/vm/forks/petersburg/blocks.py

@@ -0,0 +1,22 @@
+from rlp.sedes import (
+    CountableList,
+)
+from eth.rlp.headers import (
+    BlockHeader,
+)
+from eth.vm.forks.byzantium.blocks import (
+    ByzantiumBlock,
+)
+
+from .transactions import (
+    PetersburgTransaction,
+)
+
+
+class PetersburgBlock(ByzantiumBlock):
+    transaction_class = PetersburgTransaction
+    fields = [
+        ('header', BlockHeader),
+        ('transactions', CountableList(transaction_class)),
+        ('uncles', CountableList(BlockHeader))
+    ]

eth/vm/forks/petersburg/computation.py

@@ -0,0 +1,39 @@
+from eth_utils.toolz import (
+    merge,
+)
+
+from eth.vm.forks.byzantium.computation import (
+    BYZANTIUM_PRECOMPILES
+)
+from eth.vm.forks.byzantium.computation import (
+    ByzantiumComputation
+)
+from eth.vm.gas_meter import (
+    allow_negative_refund_strategy,
+    GasMeter,
+)
+
+from .opcodes import PETERSBURG_OPCODES
+
+PETERSBURG_PRECOMPILES = merge(
+    BYZANTIUM_PRECOMPILES,
+    {
+        # TODO: add new precompiles
+    },
+)
+
+
+class PetersburgComputation(ByzantiumComputation):
+    """
+    A class for all execution computations in the ``Petersburg`` fork.
+    Inherits from :class:`~eth.vm.forks.byzantium.computation.ByzantiumComputation`
+    """
+    # Override
+    opcodes = PETERSBURG_OPCODES
+    _precompiles = PETERSBURG_PRECOMPILES
+
+    def get_gas_meter(self) -> GasMeter:
+        return GasMeter(
+            self.msg.gas,
+            allow_negative_refund_strategy
+        )

eth/vm/forks/petersburg/constants.py

@@ -0,0 +1,6 @@
+from eth_utils import denoms
+
+
+GAS_EXTCODEHASH_EIP1052 = 400
+
+EIP1234_BLOCK_REWARD = 2 * denoms.ether

eth/vm/forks/petersburg/headers.py

@@ -0,0 +1,13 @@
+from eth.vm.forks.byzantium.headers import (
+    configure_header,
+    create_header_from_parent,
+    compute_difficulty,
+)
+
+
+compute_petersburg_difficulty = compute_difficulty(5000000)
+
+create_petersburg_header_from_parent = create_header_from_parent(
+    compute_petersburg_difficulty
+)
+configure_petersburg_header = configure_header(compute_petersburg_difficulty)

eth/vm/forks/petersburg/opcodes.py

@@ -0,0 +1,60 @@
+import copy
+from eth_utils.toolz import (
+    merge
+)
+
+from eth import (
+    constants
+)
+from eth.vm import (
+    mnemonics,
+    opcode_values,
+)
+from eth.vm.forks.byzantium.opcodes import (
+    BYZANTIUM_OPCODES,
+)
+from eth.vm.forks.petersburg.constants import (
+    GAS_EXTCODEHASH_EIP1052
+)
+from eth.vm.logic import (
+    arithmetic,
+    context,
+    system,
+)
+from eth.vm.opcode import (
+    as_opcode
+)
+
+
+UPDATED_OPCODES = {
+    opcode_values.SHL: as_opcode(
+        logic_fn=arithmetic.shl,
+        mnemonic=mnemonics.SHL,
+        gas_cost=constants.GAS_VERYLOW,
+    ),
+    opcode_values.SHR: as_opcode(
+        logic_fn=arithmetic.shr,
+        mnemonic=mnemonics.SHR,
+        gas_cost=constants.GAS_VERYLOW,
+    ),
+    opcode_values.SAR: as_opcode(
+        logic_fn=arithmetic.sar,
+        mnemonic=mnemonics.SAR,
+        gas_cost=constants.GAS_VERYLOW,
+    ),
+    opcode_values.EXTCODEHASH: as_opcode(
+        logic_fn=context.extcodehash,
+        mnemonic=mnemonics.EXTCODEHASH,
+        gas_cost=GAS_EXTCODEHASH_EIP1052,
+    ),
+    opcode_values.CREATE2: system.Create2.configure(
+        __name__='opcode:CREATE2',
+        mnemonic=mnemonics.CREATE2,
+        gas_cost=constants.GAS_CREATE,
+    )(),
+}
+
+PETERSBURG_OPCODES = merge(
+    copy.deepcopy(BYZANTIUM_OPCODES),
+    UPDATED_OPCODES,
+)

eth/vm/forks/petersburg/state.py

@@ -0,0 +1,9 @@
+from eth.vm.forks.byzantium.state import (
+    ByzantiumState
+)
+
+from .computation import PetersburgComputation
+
+
+class PetersburgState(ByzantiumState):
+    computation_class = PetersburgComputation

eth/vm/forks/petersburg/transactions.py

@@ -0,0 +1,42 @@
+from eth_keys.datatypes import PrivateKey
+from eth_typing import Address
+
+from eth.vm.forks.byzantium.transactions import (
+    ByzantiumTransaction,
+    ByzantiumUnsignedTransaction,
+)
+
+from eth._utils.transactions import (
+    create_transaction_signature,
+)
+
+
+class PetersburgTransaction(ByzantiumTransaction):
+    @classmethod
+    def create_unsigned_transaction(cls,
+                                    *,
+                                    nonce: int,
+                                    gas_price: int,
+                                    gas: int,
+                                    to: Address,
+                                    value: int,
+                                    data: bytes) -> 'PetersburgUnsignedTransaction':
+        return PetersburgUnsignedTransaction(nonce, gas_price, gas, to, value, data)
+
+
+class PetersburgUnsignedTransaction(ByzantiumUnsignedTransaction):
+    def as_signed_transaction(self,
+                              private_key: PrivateKey,
+                              chain_id: int=None) -> PetersburgTransaction:
+        v, r, s = create_transaction_signature(self, private_key, chain_id=chain_id)
+        return PetersburgTransaction(
+            nonce=self.nonce,
+            gas_price=self.gas_price,
+            gas=self.gas,
+            to=self.to,
+            value=self.value,
+            data=self.data,
+            v=v,
+            r=r,
+            s=s,
+        )