feat(nano): Add HTTP API and CLI to re-run blocks and nano transactions

Author: msbrogli

hathor/builder/resources_builder.py

@@ -260,6 +260,7 @@ def create_resources(self) -> server.Site:
                 BlueprintSourceCodeResource,
                 NanoContractHistoryResource,
                 NanoContractStateResource,
+                NCDryRunResource,
             )
             nc_resource = Resource()
             root.putChild(b'nano_contract', nc_resource)
@@ -273,6 +274,7 @@ def create_resources(self) -> server.Site:
             nc_resource.putChild(b'state', NanoContractStateResource(self.manager))
             nc_resource.putChild(b'creation', NCCreationResource(self.manager))
             nc_resource.putChild(b'logs', NCExecLogsResource(self.manager))
+            nc_resource.putChild(b'dry_run', NCDryRunResource(self.manager))
 
         if self._args.enable_debug_api:
             debug_resource = Resource()

hathor/nanocontracts/execution/block_executor.py

@@ -19,12 +19,14 @@
 import hashlib
 import traceback
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING, Callable, Iterator
 
 from hathor.nanocontracts.exception import NCFail
 from hathor.transaction import Block, Transaction
 from hathor.transaction.exceptions import TokenNotFound
-from hathor.transaction.nc_execution_state import NCExecutionState
+
+# Type alias for the skip predicate
+ShouldSkipPredicate = Callable[[Transaction], bool]
 
 if TYPE_CHECKING:
     from hathor.conf.settings import HathorSettings
@@ -132,6 +134,8 @@ def __init__(
     def execute_block(
         self,
         block: Block,
+        *,
+        should_skip: ShouldSkipPredicate,
     ) -> Iterator[NCBlockEffect]:
         """Execute block as generator, yielding effects without applying them.
 
@@ -140,18 +144,17 @@ def execute_block(
 
         Args:
             block: The block to execute.
+            should_skip: A predicate function that determines if a transaction should be skipped.
+                This allows the caller to provide context-specific voided state tracking.
 
         Yields:
             NCBlockEffect instances representing each step of execution.
         """
-        from hathor.nanocontracts import NC_EXECUTION_FAIL_ID
-
         assert self._settings.ENABLE_NANO_CONTRACTS
         assert not block.is_genesis, "Genesis blocks should be handled separately"
 
         meta = block.get_metadata()
         assert not meta.voided_by
-        assert meta.nc_block_root_id is None
 
         parent = block.get_block_parent()
         parent_meta = parent.get_metadata()
@@ -162,10 +165,6 @@ def execute_block(
         for tx in block.iter_transactions_in_this_block():
             if not tx.is_nano_contract():
                 continue
-            tx_meta = tx.get_metadata()
-            assert tx_meta.nc_execution in {None, NCExecutionState.PENDING}
-            if tx_meta.voided_by:
-                assert NC_EXECUTION_FAIL_ID not in tx_meta.voided_by
             nc_calls.append(tx)
 
         nc_sorted_calls = self._nc_calls_sorter(block, nc_calls) if nc_calls else []
@@ -193,6 +192,7 @@ def execute_block(
                 tx=tx,
                 block_storage=block_storage,
                 rng_seed=rng_seed,
+                should_skip=should_skip,
             )
             yield result
 
@@ -212,18 +212,24 @@ def execute_transaction(
         tx: Transaction,
         block_storage: 'NCBlockStorage',
         rng_seed: bytes,
+        should_skip: ShouldSkipPredicate,
     ) -> NCTxExecutionResult:
         """Execute a single NC transaction.
 
         This method is pure and side-effect free. It does not persist anything,
         does not call callbacks, and returns all information needed by the caller
-        to handle success/failure cases."""
+        to handle success/failure cases.
+
+        Args:
+            tx: The transaction to execute.
+            block_storage: The block storage for this execution context.
+            rng_seed: The RNG seed for this transaction.
+            should_skip: Predicate to determine if transaction should be skipped.
+        """
         from hathor.nanocontracts.types import Address
 
-        tx_meta = tx.get_metadata()
-        if tx_meta.voided_by:
-            # Skip voided transactions. This might happen if a previous tx in nc_calls fails and
-            # mark this tx as voided.
+        if should_skip(tx):
+            # Skip transactions based on the caller-provided predicate.
             # Check if seqnum needs to be updated.
             nc_header = tx.get_nano_header()
             nc_address = Address(nc_header.nc_address)

hathor/nanocontracts/execution/consensus_block_executor.py

@@ -176,10 +176,24 @@ def execute_block_and_apply(
             self.initialize_empty(block, context)
             return
 
+        # Verify block hasn't been executed yet
+        meta = block.get_metadata()
+        assert meta.nc_block_root_id is None
+
+        # Create predicate that reads from database metadata
+        def should_skip(tx: Transaction) -> bool:
+            tx_meta = tx.get_metadata()
+            if tx_meta.voided_by:
+                # During normal execution, NC_EXECUTION_FAIL_ID should not be in voided_by
+                # as that is added by the executor itself after a failure
+                assert NC_EXECUTION_FAIL_ID not in tx_meta.voided_by
+                return True
+            return False
+
         # Track NC transactions for final verification (populated from NCBeginBlock)
         nc_sorted_calls: list[Transaction] = []
 
-        for effect in self._block_executor.execute_block(block):
+        for effect in self._block_executor.execute_block(block, should_skip=should_skip):
             match effect:
                 case NCBeginBlock(nc_sorted_calls=calls):
                     nc_sorted_calls = calls
@@ -228,9 +242,10 @@ def _apply_effect(
                 # Nothing to apply at block start
                 pass
 
-            case NCBeginTransaction():
-                # Nothing to apply at transaction start
-                pass
+            case NCBeginTransaction(tx=tx):
+                # Verify transaction hasn't been executed yet
+                tx_meta = tx.get_metadata()
+                assert tx_meta.nc_execution in {None, NCExecutionState.PENDING}
 
             case NCTxExecutionSuccess(tx=tx, runner=runner):
                 from hathor.nanocontracts.runner.call_info import CallType