bull crap

Author: cburgdorf

eth/db/account.py

@@ -239,11 +239,11 @@ def has_root(self, state_root: bytes) -> bool:
     #
     # Storage
     #
-    def get_storage(self, address, slot):
+    def get_storage(self, address, slot, original=False):
         validate_canonical_address(address, title="Storage Address")
         validate_uint256(slot, title="Storage Slot")
 
-        account = self._get_account(address)
+        account = self._get_account(address, original)
         storage = HashTrie(HexaryTrie(self._journaldb, account.storage_root))
 
         slot_as_key = pad32(int_to_big_endian(slot))
@@ -375,8 +375,8 @@ def account_is_empty(self, address):
     #
     # Internal
     #
-    def _get_account(self, address):
-        rlp_account = self._journaltrie.get(address, b'')
+    def _get_account(self, address, no_journal=False):
+        rlp_account = (self._trie if no_journal else self._journaltrie).get(address, b'')
         if rlp_account:
             account = rlp.decode(rlp_account, sedes=Account)
         else:

eth/vm/forks/constantinople/opcodes.py

@@ -19,6 +19,7 @@
 from eth.vm.logic import (
     arithmetic,
     context,
+    storage,
     system,
 )
 from eth.vm.opcode import (
@@ -52,6 +53,11 @@
         mnemonic=mnemonics.CREATE2,
         gas_cost=constants.GAS_CREATE,
     )(),
+    opcode_values.SSTORE: as_opcode(
+        logic_fn=storage.sstore_eip1283,
+        mnemonic=mnemonics.SSTORE,
+        gas_cost=constants.GAS_NULL,
+    ),
 }
 
 CONSTANTINOPLE_OPCODES = merge(

eth/vm/logic/storage.py

@@ -49,6 +49,71 @@ def sstore(computation):
     )
 
 
+def sstore_eip1283(computation):
+    slot, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
+
+    current_value = computation.state.account_db.get_storage(
+        address=computation.msg.storage_address,
+        slot=slot,
+    )
+
+    original_value = computation.state.account_db.get_storage(
+        address=computation.msg.storage_address,
+        slot=slot,
+        original=True
+    )
+
+    is_currently_empty = not bool(current_value)
+    is_going_to_be_empty = not bool(value)
+
+    gas_refund = 0
+
+    if current_value == value:
+        gas_cost = 200
+    else:
+        if original_value == current_value:
+            if original_value == 0:
+                gas_cost = 20000
+            else:
+                gas_cost = 5000
+
+                if value == 0:
+                    gas_refund += 15000
+        else:
+            gas_cost = 200
+
+            if original_value != 0:
+                if current_value == 0:
+                    gas_refund -= 15000
+                if value == 0:
+                    gas_refund += 15000
+
+            if original_value == value:
+                if original_value == 0:
+                    gas_refund += 19800
+                else:
+                    gas_refund += 4800
+
+    computation.consume_gas(
+        gas_cost,
+        reason="SSTORE: {0}[{1}] -> {2} (current: {3} / original: {4})".format(
+        encode_hex(computation.msg.storage_address),
+        slot,
+        value,
+        current_value,
+        original_value,
+    ))
+
+    if gas_refund:
+        computation.refund_gas(gas_refund)
+
+    computation.state.account_db.set_storage(
+        address=computation.msg.storage_address,
+        slot=slot,
+        value=value,
+    )
+
+
 def sload(computation):
     slot = computation.stack_pop(type_hint=constants.UINT256)
 

tests/core/opcodes/test_opcodes.py

@@ -456,3 +456,192 @@ def test_extcodehash(vm_class, address, expected):
 
     result = computation.stack_pop(type_hint=constants.BYTES)
     assert encode_hex(pad32(result)) == expected
+
+
+@pytest.mark.parametrize(
+    # Testcases from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-145.md#shl-shift-left
+    'vm_class, code, gas_used, refund, original',
+    (
+        (
+            ByzantiumVM,
+            '0x60006000556000600055',
+            10012,
+            0,
+            0,
+        ),
+        (
+            ByzantiumVM,
+            '0x60006000556001600055',
+            25012,
+            0,
+            0,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60006000556000600055',
+            412,
+            0,
+            0,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60006000556001600055',
+            20212,
+            0,
+            0,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60016000556000600055',
+            20212,
+            19800,
+            0,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60016000556002600055',
+            20212,
+            0,
+            0,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60016000556001600055',
+            20212,
+            0,
+            0,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60006000556000600055',
+            5212,
+            15000,
+            1,
+        ),
+        # (
+        #     ConstantinopleVM,
+        #     '0x60006000556001600055',
+        #     5212,
+        #     4800,
+        #     1,
+        # ),
+        # (
+        #     ConstantinopleVM,
+        #     '0x60006000556002600055',
+        #     5212,
+        #     0,
+        #     1,
+        # ),
+        (
+            ConstantinopleVM,
+            '0x60026000556000600055',
+            5212,
+            15000,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60026000556003600055',
+            5212,
+            0,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60026000556001600055',
+            5212,
+            4800,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60026000556002600055',
+            5212,
+            0,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60016000556000600055',
+            5212,
+            15000,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60016000556002600055',
+            5212,
+            0,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x60016000556001600055',
+            412,
+            0,
+            1,
+        ),
+        (
+            ConstantinopleVM,
+            '0x600160005560006000556001600055',
+            40218,
+            19800,
+            0,
+        ),
+        # (
+        #     ConstantinopleVM,
+        #     '0x600060005560016000556000600055',
+        #     10218,
+        #     19800,
+        #     1,
+        # ),
+    )
+)
+def test_sstore(vm_class, code, gas_used, refund, original):
+    computation = shit_to_be_refactored(
+        vm_class,
+        code=decode_hex(code),
+        original_storage_value=original
+    )
+
+    comp = computation.apply_message()
+    assert comp.get_gas_refund() == refund
+    assert comp.get_gas_used() == gas_used
+
+
+def shit_to_be_refactored(vm_class,
+                        data=b'',
+                        init_code=b'',
+                        code=b'',
+                        original_storage_value=0,
+                        gas=10000000000000000):
+
+    message = Message(
+        to=CANONICAL_ADDRESS_A,
+        sender=CANONICAL_ADDRESS_B,
+        create_address=CANONICAL_ADDRESS_B,
+        value=100,
+        data=data,
+        code=code,
+        gas=gas,
+    )
+
+    tx_context = vm_class._state_class.transaction_context_class(
+        gas_price=1,
+        origin=CANONICAL_ADDRESS_B,
+    )
+
+    #vm = chain.get_vm()
+    vm = vm_class(GENESIS_HEADER, ChainDB(AtomicDB()))
+
+    computation = vm_class._state_class.computation_class(
+        state=vm.state,
+        message=message,
+        transaction_context=tx_context,
+    )
+
+    computation.state.account_db.set_balance(CANONICAL_ADDRESS_B, 100000000000)
+    computation.state.account_db.set_storage(CANONICAL_ADDRESS_B, 0, original_storage_value)
+    computation.state.account_db.persist()
+
+    return computation