Call a new hook when a transaction is applied

Also, supply a header that includes the expected amount of gas to be
used by the full block. This allows for things like monitoring the
progress of the block in between transactions if they are slow.
Executing transactions can be very slow in Beam Sync, for example.

Author: carver

eth/abc.py

@@ -2666,6 +2666,25 @@ def get_block(self) -> BlockAPI:
         """
         ...
 
+    #
+    # Hooks
+    #
+
+    def transaction_applied_hook(
+            self,
+            transaction_index: int,
+            transactions: Sequence[SignedTransactionAPI],
+            base_header: BlockHeaderAPI,
+            partial_header: BlockHeaderAPI,
+            computation: ComputationAPI,
+            receipt: ReceiptAPI) -> None:
+        """
+        A hook for a subclass to use as a way to note that a transaction was applied.
+        This only gets triggered as part of `apply_all_transactions`, which is called
+        by `block_import`.
+        """
+        pass
+
     #
     # Execution
     #

eth/chains/base.py

@@ -468,7 +468,10 @@ def import_block(self,
             )
 
         base_header_for_import = self.create_header_from_parent(parent_header)
-        block_result = self.get_vm(base_header_for_import).import_block(block)
+        # Make a copy of the empty header, adding in the expected amount of gas used. This
+        #   allows for richer logging in the VM.
+        annotated_header = base_header_for_import.copy(gas_used=block.header.gas_used)
+        block_result = self.get_vm(annotated_header).import_block(block)
         imported_block = block_result.block
 
         # Validate the imported block.

eth/vm/base.py

@@ -227,7 +227,8 @@ def apply_all_transactions(
         transactions: Sequence[SignedTransactionAPI],
         base_header: BlockHeaderAPI
     ) -> Tuple[BlockHeaderAPI, Tuple[ReceiptAPI, ...], Tuple[ComputationAPI, ...]]:
-        if base_header.block_number != self.get_header().block_number:
+        vm_header = self.get_header()
+        if base_header.block_number != vm_header.block_number:
             raise ValidationError(
                 f"This VM instance must only work on block #{self.get_header().block_number}, "
                 f"but the target header has block #{base_header.block_number}"
@@ -238,7 +239,7 @@ def apply_all_transactions(
         previous_header = base_header
         result_header = base_header
 
-        for transaction in transactions:
+        for transaction_index, transaction in enumerate(transactions):
             try:
                 snapshot = self.state.snapshot()
                 receipt, computation = self.apply_transaction(
@@ -254,6 +255,15 @@ def apply_all_transactions(
             receipts.append(receipt)
             computations.append(computation)
 
+            self.transaction_applied_hook(
+                transaction_index,
+                transactions,
+                vm_header,
+                result_header,
+                computation,
+                receipt,
+            )
+
         receipts_tuple = tuple(receipts)
         computations_tuple = tuple(computations)
 
@@ -286,7 +296,9 @@ def import_block(self, block: BlockAPI) -> BlockAndMetaWitness:
         execution_context = self.create_execution_context(
             block.header, self.previous_hashes, self.chain_context)
 
-        header = self.get_header()
+        # Zero out the gas_used before applying transactions. Each applied transaction will
+        #   increase the gas used in the final new_header.
+        header = self.get_header().copy(gas_used=0)
         # we need to re-initialize the `state` to update the execution context.
         self._state = self.get_state_class()(self.chaindb.db, execution_context, header.state_root)
 

newsfragments/1950.feature.rst

@@ -0,0 +1,3 @@
+Add a new hook :meth:`eth.abc.VirtualMachineAPI.transaction_applied_hook` which is triggered after
+each transaction in ``apply_all_transactions``, which is called by ``import_block``. The first use
+case is reporting progress in the middle of Beam Sync.