feat(dynamic-transaction-model): fee verification using fee header and nc

hathor/builder/builder.py

@@ -590,10 +590,12 @@ def _get_or_create_verification_service(self) -> VerificationService:
             settings = self._get_or_create_settings()
             verifiers = self._get_or_create_vertex_verifiers()
             storage = self._get_or_create_tx_storage()
+            nc_storage_factory = self._get_or_create_nc_storage_factory()
             self._verification_service = VerificationService(
                 settings=settings,
                 verifiers=verifiers,
                 tx_storage=storage,
+                nc_storage_factory=nc_storage_factory,
             )
 
         return self._verification_service

hathor/builder/cli_builder.py

@@ -292,6 +292,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             settings=settings,
             verifiers=vertex_verifiers,
             tx_storage=tx_storage,
+            nc_storage_factory=self.nc_storage_factory,
         )
 
         cpu_mining_service = CpuMiningService()

hathor/cli/mining.py

@@ -142,7 +142,7 @@ def execute(args: Namespace) -> None:
             from hathor.verification.vertex_verifiers import VertexVerifiers
             settings = get_global_settings()
             daa = DifficultyAdjustmentAlgorithm(settings=settings)
-            verification_params = VerificationParams.default_for_mempool()
+            verification_params = VerificationParams(nc_block_root_id=None, enable_checkdatasig_count=True)
             verifiers = VertexVerifiers.create_defaults(
                 reactor=Mock(),
                 settings=settings,

hathor/consensus/block_consensus.py

@@ -25,6 +25,7 @@
 from hathor.consensus.context import ReorgInfo
 from hathor.feature_activation.feature import Feature
 from hathor.transaction import BaseTransaction, Block, Transaction
+from hathor.transaction.exceptions import TokenNotFound
 from hathor.transaction.nc_execution_state import NCExecutionState
 from hathor.transaction.types import MetaNCCallRecord
 from hathor.util import classproperty
@@ -37,6 +38,7 @@
     from hathor.nanocontracts.nc_exec_logs import NCLogStorage
     from hathor.nanocontracts.runner import Runner
     from hathor.nanocontracts.runner.runner import RunnerFactory
+    from hathor.nanocontracts.storage import NCBlockStorage
 
 logger = get_logger()
 
@@ -236,8 +238,17 @@ def _nc_execute_calls(self, block: Block, *, is_reorg: bool) -> None:
 
             runner = self._runner_factory.create(block_storage=block_storage, seed=seed_hasher.digest())
             exception_and_tb: tuple[NCFail, str] | None = None
+            token_dict = tx.get_complete_token_info(block_storage)
+            should_verify_sum_after_execution = any(token_info.version is None for token_info in token_dict.values())
+
             try:
                 runner.execute_from_tx(tx)
+
+                # after the execution we have the latest state in the storage
+                # and at this point no tokens pending creation
+                if should_verify_sum_after_execution:
+                    self._verify_sum_after_execution(tx, block_storage)
+
             except NCFail as e:
                 kwargs: dict[str, Any] = {}
                 if tx.name:
@@ -301,6 +312,19 @@ def _nc_execute_calls(self, block: Block, *, is_reorg: bool) -> None:
                 case _:  # pragma: no cover
                     assert_never(tx_meta.nc_execution)
 
+    def _verify_sum_after_execution(self, tx: Transaction, block_storage: NCBlockStorage) -> None:
+        from hathor import NCFail
+        from hathor.verification.transaction_verifier import TransactionVerifier
+        try:
+            token_dict = tx.get_complete_token_info(block_storage)
+            TransactionVerifier.verify_sum(self._settings, token_dict)
+        except TokenNotFound as e:
+            # At this point, any nonexistent token would have made a prior validation fail. For example, if there
+            # was a withdrawal of a nonexistent token, it would have failed in the balance validation before.
+            raise AssertionError from e
+        except Exception as e:
+            raise NCFail from e
+
     def nc_update_metadata(self, tx: Transaction, runner: 'Runner') -> None:
         from hathor.nanocontracts.runner.types import CallType
 

hathor/dag_builder/artifacts.py

@@ -85,7 +85,13 @@ def propagate_with(
                     if new_relayed_vertex:
                         assert manager.vertex_handler.on_new_relayed_vertex(vertex)
                     else:
-                        params = VerificationParams(enable_checkdatasig_count=True, enable_nano=True)
+                        best_block = manager.tx_storage.get_best_block()
+                        best_block_meta = best_block.get_metadata()
+                        params = VerificationParams(
+                            enable_checkdatasig_count=True,
+                            enable_nano=True,
+                            nc_block_root_id=best_block_meta.nc_block_root_id,
+                        )
                         assert manager.vertex_handler._old_on_new_vertex(vertex, params)
                 except Exception as e:
                     raise Exception(f'failed on_new_tx({node.name})') from e

hathor/nanocontracts/balance_rules.py

@@ -30,8 +30,7 @@
     NCGrantAuthorityAction,
     NCWithdrawalAction,
 )
-from hathor.transaction.token_info import TokenInfoDict
-from hathor.transaction.transaction import TokenInfo
+from hathor.transaction.token_info import TokenInfoDict, TokenVersion
 
 T = TypeVar('T', bound=BaseAction)
 
@@ -101,10 +100,13 @@ class _DepositRules(BalanceRules[NCDepositAction]):
 
     @override
     def verification_rule(self, token_dict: TokenInfoDict) -> None:
-        token_info = token_dict.get(self.action.token_uid, TokenInfo.get_default())
+        token_info = token_dict[self.action.token_uid]
         token_info.amount = token_info.amount + self.action.amount
         token_dict[self.action.token_uid] = token_info
 
+        if token_info.version == TokenVersion.FEE:
+            token_info.chargeable_outputs += 1
+
     @override
     def nc_callee_execution_rule(self, callee_changes_tracker: NCChangesTracker) -> None:
         callee_changes_tracker.add_balance(self.action.token_uid, self.action.amount)
@@ -125,10 +127,13 @@ class _WithdrawalRules(BalanceRules[NCWithdrawalAction]):
 
     @override
     def verification_rule(self, token_dict: TokenInfoDict) -> None:
-        token_info = token_dict.get(self.action.token_uid, TokenInfo.get_default())
+        token_info = token_dict[self.action.token_uid]
         token_info.amount = token_info.amount - self.action.amount
         token_dict[self.action.token_uid] = token_info
 
+        if token_info.version == TokenVersion.FEE:
+            token_info.chargeable_inputs += 1
+
     @override
     def nc_callee_execution_rule(self, callee_changes_tracker: NCChangesTracker) -> None:
         callee_changes_tracker.add_balance(self.action.token_uid, -self.action.amount)
@@ -150,7 +155,7 @@ class _GrantAuthorityRules(BalanceRules[NCGrantAuthorityAction]):
     @override
     def verification_rule(self, token_dict: TokenInfoDict) -> None:
         assert self.action.token_uid != HATHOR_TOKEN_UID
-        token_info = token_dict.get(self.action.token_uid, TokenInfo.get_default())
+        token_info = token_dict[self.action.token_uid]
         if self.action.mint and not token_info.can_mint:
             raise NCInvalidAction(
                 f'{self.action.name} token {self.action.token_uid.hex()} requires mint, but no input has it'
@@ -202,7 +207,7 @@ class _AcquireAuthorityRules(BalanceRules[NCAcquireAuthorityAction]):
     @override
     def verification_rule(self, token_dict: TokenInfoDict) -> None:
         assert self.action.token_uid != HATHOR_TOKEN_UID
-        token_info = token_dict.get(self.action.token_uid, TokenInfo.get_default())
+        token_info = token_dict[self.action.token_uid]
         token_info.can_mint = token_info.can_mint or self.action.mint
         token_info.can_melt = token_info.can_melt or self.action.melt
         token_dict[self.action.token_uid] = token_info

hathor/nanocontracts/blueprint_env.py

@@ -17,7 +17,6 @@
 from typing import TYPE_CHECKING, Any, Collection, Sequence, TypeAlias, final
 
 from hathor.conf.settings import HATHOR_TOKEN_UID
-from hathor.nanocontracts.storage import NCContractStorage
 from hathor.nanocontracts.types import Amount, BlueprintId, ContractId, NCAction, NCFee, TokenUid
 
 if TYPE_CHECKING:
@@ -27,6 +26,7 @@
     from hathor.nanocontracts.proxy_accessor import ProxyAccessor
     from hathor.nanocontracts.rng import NanoRNG
     from hathor.nanocontracts.runner import Runner
+    from hathor.nanocontracts.storage import NCContractStorage
 
 
 NCAttrCache: TypeAlias = dict[bytes, Any] | None

hathor/nanocontracts/nc_types/token_version_nc_type.py

@@ -0,0 +1,26 @@
+#  Copyright 2025 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 typing_extensions import override
+
+from hathor.nanocontracts.nc_types.sized_int_nc_type import Uint8NCType
+from hathor.serialization import Deserializer
+from hathor.transaction.token_info import TokenVersion
+
+
+class TokenVersionNCType(Uint8NCType):
+    @override
+    def _deserialize(self, deserializer: Deserializer, /) -> TokenVersion:
+        value = super()._deserialize(deserializer)
+        return TokenVersion(value)

hathor/nanocontracts/storage/block_storage.py

@@ -19,7 +19,7 @@
 
 from hathor.nanocontracts.exception import NanoContractDoesNotExist
 from hathor.nanocontracts.nc_types.dataclass_nc_type import make_dataclass_nc_type
-from hathor.nanocontracts.nc_types.sized_int_nc_type import Uint8NCType
+from hathor.nanocontracts.nc_types.token_version_nc_type import TokenVersionNCType
 from hathor.nanocontracts.storage.contract_storage import NCContractStorage
 from hathor.nanocontracts.storage.patricia_trie import NodeId, PatriciaTrie
 from hathor.nanocontracts.storage.token_proxy import TokenProxy
@@ -64,7 +64,7 @@ class NCBlockStorage:
     _TOKEN_DESCRIPTION_NC_TYPE = make_dataclass_nc_type(
         TokenDescription,
         extra_nc_types_map={
-            TokenVersion: Uint8NCType,
+            TokenVersion: TokenVersionNCType,
         },
     )
 

hathor/p2p/sync_v2/transaction_streaming_client.py

@@ -47,11 +47,17 @@ def __init__(self,
         self.protocol = self.sync_agent.protocol
         self.tx_storage = self.sync_agent.tx_storage
         self.verification_service = self.protocol.node.verification_service
-        # XXX: since it's not straightforward to get the correct block, it's OK to just disable checkdatasig counting,
+
+        # XXX: Since it's not straightforward to get the correct block, it's OK to just disable checkdatasig counting,
         #      it will be correctly enabled when doing a full validation anyway.
-        self.verification_params = VerificationParams(enable_checkdatasig_count=False)
-        self.reactor = sync_agent.reactor
+        #      We can also set the `nc_block_root_id` to `None` because we only call `verify_basic`,
+        #      which doesn't need it.
+        self.verification_params = VerificationParams(
+            enable_checkdatasig_count=False,
+            nc_block_root_id=None,
+        )
 
+        self.reactor = sync_agent.reactor
         self.log = logger.new(peer=self.protocol.get_short_peer_id())
 
         # List of blocks from which we will receive transactions.

hathor/transaction/base_transaction.py

@@ -261,7 +261,7 @@ def is_transaction(self) -> bool:
         raise NotImplementedError
 
     def is_nano_contract(self) -> bool:
-        """Return True if this transaction is a nano contract or not."""
+        """Return whether this transaction is a nano contract."""
         return False
 
     def has_fees(self) -> bool:

hathor/transaction/exceptions.py

@@ -274,3 +274,7 @@ class FeeHeaderTokenNotFound(InvalidFeeHeader):
 
 class InvalidFeeAmount(InvalidFeeHeader):
     """Invalid fee amount"""
+
+
+class TokenNotFound(TxValidationError):
+    """Token not found."""

hathor/transaction/resources/create_tx.py

@@ -119,7 +119,10 @@ def _verify_unsigned_skip_pow(self, tx: Transaction) -> None:
         # need to run verify_inputs first to check if all inputs exist
         verifiers.tx.verify_inputs(tx, skip_script=True)
         verifiers.vertex.verify_parents(tx)
-        verifiers.tx.verify_sum(tx.get_complete_token_info())
+
+        best_block = self.manager.tx_storage.get_best_block()
+        block_storage = self.manager.get_nc_block_storage(best_block)
+        verifiers.tx.verify_sum(self.manager._settings, tx.get_complete_token_info(block_storage))
 
 
 CreateTxResource.openapi = {

hathor/transaction/storage/migrations/nc_storage_compat1.py → hathor/transaction/storage/migrations/nc_storage_compat2.py

@@ -29,7 +29,7 @@ def skip_empty_db(self) -> bool:
         return True
 
     def get_db_name(self) -> str:
-        return 'nc_storage_compat1'
+        return 'nc_storage_compat2'
 
     def run(self, storage: 'TransactionStorage') -> None:
         raise Exception('Cannot migrate your database due to an incompatible change in the nanocontracts storage. '

hathor/transaction/storage/transaction_storage.py

@@ -44,7 +44,7 @@
     add_closest_ancestor_block,
     change_score_acc_weight_metadata,
     include_funds_for_first_block,
-    nc_storage_compat1,
+    nc_storage_compat2,
 )
 from hathor.transaction.storage.tx_allow_scope import TxAllowScope, tx_allow_context
 from hathor.transaction.transaction import Transaction
@@ -104,7 +104,7 @@ class TransactionStorage(ABC):
         change_score_acc_weight_metadata.Migration,
         add_closest_ancestor_block.Migration,
         include_funds_for_first_block.Migration,
-        nc_storage_compat1.Migration,
+        nc_storage_compat2.Migration,
     ]
 
     _migrations: list[BaseMigration]

hathor/transaction/token_creation_tx.py

@@ -18,6 +18,7 @@
 from typing_extensions import override
 
 from hathor.conf.settings import HathorSettings
+from hathor.nanocontracts.storage import NCBlockStorage
 from hathor.transaction.base_transaction import TxInput, TxOutput, TxVersion
 from hathor.transaction.storage import TransactionStorage  # noqa: F401
 from hathor.transaction.token_info import TokenInfo, TokenInfoDict, TokenVersion
@@ -250,10 +251,10 @@ def to_json_extended(self) -> dict[str, Any]:
         return json
 
     @override
-    def _get_token_info_from_inputs(self) -> TokenInfoDict:
-        token_dict = super()._get_token_info_from_inputs()
+    def _get_token_info_from_inputs(self, nc_block_storage: NCBlockStorage) -> TokenInfoDict:
+        token_dict = super()._get_token_info_from_inputs(nc_block_storage)
 
         # we add the created token's info to token_dict, as the creation tx allows for mint/melt
-        token_dict[self.hash] = TokenInfo.get_default(version=self.token_version, can_mint=True, can_melt=True)
+        token_dict[self.hash] = TokenInfo(version=self.token_version, can_mint=True, can_melt=True)
 
         return token_dict