fix(nano): Fix voidness clearing during reorg

Author: msbrogli

hathor/consensus/block_consensus.py

@@ -13,12 +13,13 @@
 # limitations under the License.
 
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Iterable, Optional, cast
+from typing import TYPE_CHECKING, Any, Iterable, Optional, assert_never, cast
 
 from structlog import get_logger
 
 from hathor.conf.get_settings import get_global_settings
 from hathor.transaction import BaseTransaction, Block, Transaction
+from hathor.transaction.nc_execution_state import NCExecutionState
 from hathor.util import classproperty
 from hathor.utils.weight import weight_to_work
 
@@ -140,10 +141,10 @@ def _nc_execute_calls(self, block: Block, *, is_reorg: bool) -> None:
                             tx_conflict_meta = tx_conflict.get_metadata()
                             assert tx_conflict_meta.first_block is None
                             assert tx_conflict_meta.voided_by
+                    self.context.transaction_algorithm.remove_voided_by(tx, tx.hash)
                     tx_meta.voided_by = None
                     self.context.save(tx)
-            if tx_meta.voided_by:
-                continue
+            tx_meta.nc_execution = NCExecutionState.PENDING
             nc_calls.append(tx)
 
         if not nc_calls:
@@ -160,6 +161,8 @@ def _nc_execute_calls(self, block: Block, *, is_reorg: bool) -> None:
             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.
+                tx_meta.nc_execution = NCExecutionState.SKIPPED
+                self.context.save(tx)
                 continue
 
             from hathor.nanocontracts.runner import Runner
@@ -169,6 +172,8 @@ def _nc_execute_calls(self, block: Block, *, is_reorg: bool) -> None:
             runner = Runner(tx.storage, storage_factory, block_trie)
             try:
                 tx.execute(runner)
+                tx_meta.nc_execution = NCExecutionState.SUCCESS
+                self.context.save(tx)
                 # TODO Avoid calling multiple commits for the same contract. The best would be to call the commit
                 #      method once per contract per block, just like we do for the block_trie. This ensures we will
                 #      have a clean database with no orphan nodes.
@@ -183,11 +188,28 @@ def _nc_execute_calls(self, block: Block, *, is_reorg: bool) -> None:
         meta.nc_block_root_id = block_trie.root.id
         self.context.save(block)
 
+        for tx in nc_calls:
+            tx_meta = tx.get_metadata()
+            assert tx_meta.nc_execution is not None
+            match tx_meta.nc_execution:
+                case NCExecutionState.PENDING:
+                    assert False  # should never happen
+                case NCExecutionState.SUCCESS:
+                    assert tx_meta.voided_by is None
+                case NCExecutionState.FAILURE:
+                    assert tx_meta.voided_by == {tx.hash, self._settings.NC_EXECUTION_FAIL_ID}
+                case NCExecutionState.SKIPPED:
+                    assert tx_meta.voided_by
+                    assert self._settings.NC_EXECUTION_FAIL_ID not in tx_meta.voided_by
+                case _:
+                    assert_never(tx_meta.nc_execution)
+
     def mark_as_nc_fail_execution(self, tx: Transaction) -> None:
         """Mark that a transaction failed execution. It also propagates its voidedness through the DAG of funds."""
         assert tx.storage is not None
         tx_meta = tx.get_metadata()
         tx_meta.add_voided_by(self._settings.NC_EXECUTION_FAIL_ID)
+        tx_meta.nc_execution = NCExecutionState.FAILURE
         self.context.save(tx)
         self.context.transaction_algorithm.add_voided_by(tx,
                                                          tx.hash,

hathor/dag_builder/vertex_exporter.py

@@ -417,6 +417,7 @@ def create_vertex(self, node: DAGNode) -> BaseTransaction:
         assert node.name not in self._vertices
         self._vertice_per_id[vertex.hash] = vertex
         self._vertices[node.name] = vertex
+        vertex.name = node.name
         return vertex
 
     def export(self) -> Iterator[tuple[DAGNode, BaseTransaction]]:

hathor/nanocontracts/blueprint.py

@@ -18,7 +18,6 @@
 
 from structlog import get_logger
 
-from hathor.conf import HathorSettings
 from hathor.nanocontracts.fields import get_field_for_attr
 from hathor.nanocontracts.storage import NCStorage
 from hathor.nanocontracts.types import ContractId, NCAction, TokenUid
@@ -27,7 +26,6 @@
     from hathor.nanocontracts.runner import Runner
 
 logger = get_logger()
-settings = HathorSettings()
 
 
 class _BlueprintBase(type):

hathor/nanocontracts/method_parser.py

@@ -18,20 +18,20 @@
 
 from structlog import get_logger
 
-from hathor.conf import HathorSettings
+from hathor.conf.get_settings import get_global_settings
 from hathor.nanocontracts.context import Context
 from hathor.nanocontracts.exception import NCSerializationArgTooLong, NCSerializationError
 from hathor.nanocontracts.serializers import Deserializer, Serializer
 from hathor.transaction.util import unpack
 
 logger = get_logger()
-settings = HathorSettings()
 
 
 class NCMethodParser:
     """Utility class to serialize and deserialize method arguments."""
     def __init__(self, method: Callable) -> None:
         self.method = method
+        self._settings = get_global_settings()
 
     def get_method_args(self) -> list[tuple[str, Type[Any]]]:
         """Return the list of arguments for the method, including the types."""
@@ -59,7 +59,7 @@ def serialize_args(self, args: list[Any]) -> bytes:
         assert len(args) == len(method_args), f'{len(args)} != {len(method_args)} ({method_args})'
         for (arg_name, arg_type), arg_value in zip(method_args, args):
             arg_bytes = serializer.from_type(arg_type, arg_value)
-            if len(arg_bytes) > settings.NC_MAX_LENGTH_SERIALIZED_ARG:
+            if len(arg_bytes) > self._settings.NC_MAX_LENGTH_SERIALIZED_ARG:
                 raise NCSerializationArgTooLong
             ret.append(struct.pack('!H', len(arg_bytes)))
             ret.append(arg_bytes)

hathor/nanocontracts/on_chain_blueprint.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import ast
 import zlib
 from dataclasses import InitVar, dataclass, field
@@ -24,7 +26,6 @@
 from typing_extensions import Self, override
 
 from hathor.conf.get_settings import get_global_settings
-from hathor.conf.settings import HathorSettings
 from hathor.crypto.util import get_public_key_bytes_compressed
 from hathor.nanocontracts.blueprint import Blueprint
 from hathor.nanocontracts.exception import OCBOutOfFuelDuringLoading, OCBOutOfMemoryDuringLoading
@@ -34,6 +35,7 @@
 from hathor.transaction.util import VerboseCallback, int_to_bytes, unpack, unpack_len
 
 if TYPE_CHECKING:
+    from hathor.conf.settings import HathorSettings
     from hathor.nanocontracts.storage import NCStorage  # noqa: F401
     from hathor.transaction.storage import TransactionStorage  # noqa: F401
 

hathor/reward_lock/reward_lock.py

@@ -34,14 +34,14 @@ def iter_spent_rewards(tx: 'Transaction', storage: 'VertexStorageProtocol') -> I
             yield spent_tx
 
 
-def is_spent_reward_locked(settings: HathorSettings, tx: 'Transaction') -> bool:
+def is_spent_reward_locked(settings: 'HathorSettings', tx: 'Transaction') -> bool:
     """ Check whether any spent reward is currently locked, considering only the block rewards spent by this tx
     itself, and not the inherited `min_height`"""
     return get_spent_reward_locked_info(settings, tx, not_none(tx.storage)) is not None
 
 
 def get_spent_reward_locked_info(
-    settings: HathorSettings,
+    settings: 'HathorSettings',
     tx: 'Transaction',
     storage: 'VertexStorageProtocol',
 ) -> Optional['RewardLockedInfo']:
@@ -71,7 +71,7 @@ def get_minimum_best_height(storage: 'VertexStorageProtocol') -> int:
     return best_height
 
 
-def _spent_reward_needed_height(settings: HathorSettings, block: Block, best_height: int) -> int:
+def _spent_reward_needed_height(settings: 'HathorSettings', block: Block, best_height: int) -> int:
     """ Returns height still needed to unlock this `block` reward: 0 means it's unlocked."""
     spent_height = block.get_height()
     spend_blocks = best_height - spent_height

hathor/transaction/base_transaction.py

@@ -198,6 +198,9 @@ def __init__(
         self._hash: VertexId | None = hash  # Stored as bytes.
         self._static_metadata = None
 
+        # A name solely for debugging purposes.
+        self.name: str | None = None
+
         self.MAX_NUM_INPUTS = self._settings.MAX_NUM_INPUTS
         self.MAX_NUM_OUTPUTS = self._settings.MAX_NUM_OUTPUTS
 

hathor/transaction/nc_execution_state.py

@@ -0,0 +1,23 @@
+#  Copyright 2023 Hathor Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from enum import Enum, unique
+
+
+@unique
+class NCExecutionState(Enum):
+    PENDING = 'pending'  # aka, not even tried to execute it
+    SUCCESS = 'success'  # execution was sucessful
+    FAILURE = 'failure'  # execution failed and the transaction is voided
+    SKIPPED = 'skipped'  # execution was skipped, usually because the transaction was voided

hathor/transaction/transaction_metadata.py

@@ -20,6 +20,7 @@
 from hathor.conf.get_settings import get_global_settings
 from hathor.feature_activation.feature import Feature
 from hathor.feature_activation.model.feature_state import FeatureState
+from hathor.transaction.nc_execution_state import NCExecutionState
 from hathor.transaction.validation_state import ValidationState
 from hathor.util import json_dumpb, json_loadb, practically_equal
 from hathor.utils.weight import work_to_weight
@@ -48,6 +49,7 @@ class TransactionMetadata:
 
     # Used to store the root node id of the contract tree related to this block.
     nc_block_root_id: Optional[bytes]
+    nc_execution: Optional[NCExecutionState]
 
     # A dict of features in the feature activation process and their respective state. Must only be used by Blocks,
     # is None otherwise. This is only used for caching, so it can be safely cleared up, as it would be recalculated
@@ -76,6 +78,7 @@ def __init__(
         self._tx_ref = None
 
         self.nc_block_root_id = nc_block_root_id
+        self.nc_execution = None
 
         # Tx outputs that have been spent.
         # The key is the output index, while the value is a set of the transactions which spend the output.
@@ -238,6 +241,7 @@ def to_storage_json(self) -> dict[str, Any]:
             data['first_block'] = None
         data['validation'] = self.validation.name.lower()
         data['nc_block_root_id'] = self.nc_block_root_id.hex() if self.nc_block_root_id else None
+        data['nc_execution'] = self.nc_execution.value if self.nc_execution else None
         return data
 
     def to_json(self) -> dict[str, Any]:
@@ -305,6 +309,12 @@ def create_from_json(cls, data: dict[str, Any]) -> 'TransactionMetadata':
         else:
             meta.nc_block_root_id = None
 
+        nc_execution_raw = data.get('nc_execution_raw')
+        if nc_execution_raw is not None:
+            meta.nc_execution = NCExecutionState(nc_execution_raw)
+        else:
+            meta.nc_execution = None
+
         return meta
 
     @classmethod