Add VM function to execute raw bytecode (#315)

* Minimal proof of concept for exec bytecode

Construct a message and pass it through apply_computation

* Add missing origin param

* Add transaction_context

Rebase and update to work with #327 changes. Adds code_address to allow
execution of arbitrary code in the context of an existing contract per
#306 (comment).

* Allow code_address to be None

* Bugfix: pass tx_context to apply_computation

* Parametrize the computation_getter

Per @pipermerriam's suggestion

Author: lrettig

evm/vm/base.py

@@ -39,6 +39,9 @@
     validate_length_lte,
     validate_gas_limit,
 )
+from evm.vm.message import (
+    Message,
+)
 
 from .execution_context import (
     ExecutionContext,
@@ -48,8 +51,8 @@
 class VM(Configurable):
     """
     The VM class represents the Chain rules for a specific protocol definition
-    such as the Frontier or Homestead network.  Defining an Chain  defining
-    individual VM classes for each fork of the protocol rules within that
+    such as the Frontier or Homestead network.  Define a Chain which specifies
+    the individual VM classes for each fork of the protocol rules within that
     network.
     """
     chaindb = None
@@ -89,6 +92,44 @@ def apply_transaction(self, transaction):
 
         return computation, self.block
 
+    def execute_bytecode(self,
+                         origin,
+                         gas_price,
+                         gas,
+                         to,
+                         sender,
+                         value,
+                         data,
+                         code,
+                         code_address=None,
+                         ):
+        if origin is None:
+            origin = sender
+
+        # Construct a message
+        message = Message(
+            gas=gas,
+            to=to,
+            sender=sender,
+            value=value,
+            data=data,
+            code=code,
+            code_address=code_address,
+        )
+
+        # Construction a tx context
+        transaction_context = self.state.get_transaction_context_class()(
+            gas_price=gas_price,
+            origin=origin,
+        )
+
+        # Execute it in the VM
+        return self.state.get_computation(message, transaction_context).apply_computation(
+            self.state,
+            message,
+            transaction_context,
+        )
+
     #
     # Mining
     #
@@ -433,7 +474,7 @@ def compute_difficulty(cls, parent_header, timestamp):
     #
     def clear_journal(self):
         """
-        Cleare the journal.  This should be called at any point of VM execution
+        Clear the journal.  This should be called at any point of VM execution
         where the statedb is being committed, such as after a transaction has
         been applied to a block.
         """

evm/vm_state.py

@@ -201,7 +201,7 @@ def apply_transaction(
         """
         Apply transaction to the given block
 
-        :param transaction: the transaction need to be applied
+        :param transaction: the transaction to apply
         :param block: the block which the transaction applies on
         :type transaction: Transaction
         :type block: Block

tests/json-fixtures/test_virtual_machine.py

@@ -135,23 +135,7 @@ def vm_class(request):
         assert False, "Unsupported VM: {0}".format(request.param)
 
 
-def test_vm_fixtures(fixture, vm_class):
-    chaindb = ChainDB(get_db_backend())
-    header = BlockHeader(
-        coinbase=fixture['env']['currentCoinbase'],
-        difficulty=fixture['env']['currentDifficulty'],
-        block_number=fixture['env']['currentNumber'],
-        gas_limit=fixture['env']['currentGasLimit'],
-        timestamp=fixture['env']['currentTimestamp'],
-    )
-    vm = vm_class(header=header, chaindb=chaindb)
-    vm_state = vm.state
-    with vm_state.state_db() as state_db:
-        setup_state_db(fixture['pre'], state_db)
-        code = state_db.get_code(fixture['exec']['address'])
-    # Update state_root manually
-    vm.block.header.state_root = vm_state.state_root
-
+def fixture_to_computation(fixture, code, vm):
     message = Message(
         to=fixture['exec']['address'],
         sender=fixture['exec']['caller'],
@@ -164,11 +148,52 @@ def test_vm_fixtures(fixture, vm_class):
         origin=fixture['exec']['origin'],
         gas_price=fixture['exec']['gasPrice'],
     )
-    computation = vm.state.get_computation(message, transaction_context).apply_computation(
+    return vm.state.get_computation(message, transaction_context).apply_computation(
         vm.state,
         message,
         transaction_context,
     )
+
+
+def fixture_to_bytecode_computation(fixture, code, vm):
+    return vm.execute_bytecode(
+        origin=fixture['exec']['origin'],
+        gas_price=fixture['exec']['gasPrice'],
+        gas=fixture['exec']['gas'],
+        to=fixture['exec']['address'],
+        sender=fixture['exec']['caller'],
+        value=fixture['exec']['value'],
+        data=fixture['exec']['data'],
+        code=code,
+    )
+
+
+@pytest.mark.parametrize(
+    'computation_getter',
+    (
+        fixture_to_bytecode_computation,
+        fixture_to_computation,
+    ),
+)
+def test_vm_fixtures(fixture, vm_class, computation_getter):
+    chaindb = ChainDB(get_db_backend())
+    header = BlockHeader(
+        coinbase=fixture['env']['currentCoinbase'],
+        difficulty=fixture['env']['currentDifficulty'],
+        block_number=fixture['env']['currentNumber'],
+        gas_limit=fixture['env']['currentGasLimit'],
+        timestamp=fixture['env']['currentTimestamp'],
+    )
+    vm = vm_class(header=header, chaindb=chaindb)
+    vm_state = vm.state
+    with vm_state.state_db() as state_db:
+        setup_state_db(fixture['pre'], state_db)
+        code = state_db.get_code(fixture['exec']['address'])
+    # Update state_root manually
+    vm.block.header.state_root = vm_state.state_root
+
+    computation = computation_getter(fixture, code, vm)
+
     # Update state_root manually
     vm.block.header.state_root = computation.vm_state.state_root