Refactor/metadata/migrate feature states 3

hathor/builder/builder.py

@@ -29,7 +29,6 @@
 from hathor.execution_manager import ExecutionManager
 from hathor.feature_activation.bit_signaling_service import BitSignalingService
 from hathor.feature_activation.feature import Feature
-from hathor.feature_activation.feature_service import FeatureService
 from hathor.feature_activation.storage.feature_activation_storage import FeatureActivationStorage
 from hathor.indexes import IndexesManager, MemoryIndexesManager, RocksDBIndexesManager
 from hathor.manager import HathorManager
@@ -71,18 +70,14 @@ class BuildArtifacts(NamedTuple):
     pubsub: PubSubManager
     consensus: ConsensusAlgorithm
     tx_storage: TransactionStorage
-    feature_service: FeatureService
     bit_signaling_service: BitSignalingService
     indexes: Optional[IndexesManager]
     wallet: Optional[BaseWallet]
     rocksdb_storage: Optional[RocksDBStorage]
     stratum_factory: Optional[StratumFactory]
 
 
-_VertexVerifiersBuilder: TypeAlias = Callable[
-    [HathorSettingsType, DifficultyAdjustmentAlgorithm, FeatureService],
-    VertexVerifiers
-]
+_VertexVerifiersBuilder: TypeAlias = Callable[[HathorSettingsType, DifficultyAdjustmentAlgorithm], VertexVerifiers]
 
 
 class Builder:
@@ -115,7 +110,6 @@ def __init__(self) -> None:
 
         self._support_features: set[Feature] = set()
         self._not_support_features: set[Feature] = set()
-        self._feature_service: Optional[FeatureService] = None
         self._bit_signaling_service: Optional[BitSignalingService] = None
 
         self._daa: Optional[DifficultyAdjustmentAlgorithm] = None
@@ -183,7 +177,6 @@ def build(self) -> BuildArtifacts:
         event_manager = self._get_or_create_event_manager()
         indexes = self._get_or_create_indexes_manager()
         tx_storage = self._get_or_create_tx_storage()
-        feature_service = self._get_or_create_feature_service()
         bit_signaling_service = self._get_or_create_bit_signaling_service()
         verification_service = self._get_or_create_verification_service()
         daa = self._get_or_create_daa()
@@ -251,7 +244,6 @@ def build(self) -> BuildArtifacts:
             wallet=wallet,
             rocksdb_storage=self._rocksdb_storage,
             stratum_factory=stratum_factory,
-            feature_service=feature_service,
             bit_signaling_service=bit_signaling_service
         )
 
@@ -266,11 +258,6 @@ def set_event_manager(self, event_manager: EventManager) -> 'Builder':
         self._event_manager = event_manager
         return self
 
-    def set_feature_service(self, feature_service: FeatureService) -> 'Builder':
-        self.check_if_can_modify()
-        self._feature_service = feature_service
-        return self
-
     def set_bit_signaling_service(self, bit_signaling_service: BitSignalingService) -> 'Builder':
         self.check_if_can_modify()
         self._bit_signaling_service = bit_signaling_service
@@ -413,6 +400,7 @@ def _get_or_create_indexes_manager(self) -> IndexesManager:
 
     def _get_or_create_tx_storage(self) -> TransactionStorage:
         indexes = self._get_or_create_indexes_manager()
+        settings = self._get_or_create_settings()
 
         if self._tx_storage is not None:
             # If a tx storage is provided, set the indexes manager to it.
@@ -424,11 +412,11 @@ def _get_or_create_tx_storage(self) -> TransactionStorage:
             store_indexes = None
 
         if self._storage_type == StorageType.MEMORY:
-            self._tx_storage = TransactionMemoryStorage(indexes=store_indexes)
+            self._tx_storage = TransactionMemoryStorage(indexes=store_indexes, settings=settings)
 
         elif self._storage_type == StorageType.ROCKSDB:
             rocksdb_storage = self._get_or_create_rocksdb_storage()
-            self._tx_storage = TransactionRocksDBStorage(rocksdb_storage, indexes=store_indexes)
+            self._tx_storage = TransactionRocksDBStorage(rocksdb_storage, indexes=store_indexes, settings=settings)
 
         else:
             raise NotImplementedError
@@ -438,7 +426,13 @@ def _get_or_create_tx_storage(self) -> TransactionStorage:
             kwargs: dict[str, Any] = {}
             if self._tx_storage_cache_capacity is not None:
                 kwargs['capacity'] = self._tx_storage_cache_capacity
-            self._tx_storage = TransactionCacheStorage(self._tx_storage, reactor, indexes=indexes, **kwargs)
+            self._tx_storage = TransactionCacheStorage(
+                self._tx_storage,
+                reactor,
+                indexes=indexes,
+                settings=settings,
+                **kwargs
+            )
 
         return self._tx_storage
 
@@ -477,27 +471,13 @@ def _get_or_create_event_manager(self) -> EventManager:
 
         return self._event_manager
 
-    def _get_or_create_feature_service(self) -> FeatureService:
-        """Return the FeatureService instance set on this builder, or a new one if not set."""
-        if self._feature_service is None:
-            settings = self._get_or_create_settings()
-            tx_storage = self._get_or_create_tx_storage()
-            self._feature_service = FeatureService(
-                feature_settings=settings.FEATURE_ACTIVATION,
-                tx_storage=tx_storage
-            )
-
-        return self._feature_service
-
     def _get_or_create_bit_signaling_service(self) -> BitSignalingService:
         if self._bit_signaling_service is None:
             settings = self._get_or_create_settings()
             tx_storage = self._get_or_create_tx_storage()
-            feature_service = self._get_or_create_feature_service()
             feature_storage = self._get_or_create_feature_storage()
             self._bit_signaling_service = BitSignalingService(
-                feature_settings=settings.FEATURE_ACTIVATION,
-                feature_service=feature_service,
+                settings=settings,
                 tx_storage=tx_storage,
                 support_features=self._support_features,
                 not_support_features=self._not_support_features,
@@ -531,17 +511,12 @@ def _get_or_create_feature_storage(self) -> FeatureActivationStorage | None:
     def _get_or_create_vertex_verifiers(self) -> VertexVerifiers:
         if self._vertex_verifiers is None:
             settings = self._get_or_create_settings()
-            feature_service = self._get_or_create_feature_service()
             daa = self._get_or_create_daa()
 
             if self._vertex_verifiers_builder:
-                self._vertex_verifiers = self._vertex_verifiers_builder(settings, daa, feature_service)
+                self._vertex_verifiers = self._vertex_verifiers_builder(settings, daa)
             else:
-                self._vertex_verifiers = VertexVerifiers.create_defaults(
-                    settings=settings,
-                    daa=daa,
-                    feature_service=feature_service,
-                )
+                self._vertex_verifiers = VertexVerifiers.create_defaults(settings=settings, daa=daa)
 
         return self._vertex_verifiers
 
@@ -567,7 +542,6 @@ def _get_or_create_vertex_handler(self) -> VertexHandler:
                 verification_service=self._get_or_create_verification_service(),
                 consensus=self._get_or_create_consensus(),
                 p2p_manager=self._get_or_create_p2p_manager(),
-                feature_service=self._get_or_create_feature_service(),
                 pubsub=self._get_or_create_pubsub(),
                 wallet=self._get_or_create_wallet(),
             )

hathor/builder/cli_builder.py

@@ -28,7 +28,6 @@
 from hathor.exception import BuilderError
 from hathor.execution_manager import ExecutionManager
 from hathor.feature_activation.bit_signaling_service import BitSignalingService
-from hathor.feature_activation.feature_service import FeatureService
 from hathor.feature_activation.storage.feature_activation_storage import FeatureActivationStorage
 from hathor.indexes import IndexesManager, MemoryIndexesManager, RocksDBIndexesManager
 from hathor.manager import HathorManager
@@ -146,7 +145,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             else:
                 indexes = RocksDBIndexesManager(self.rocksdb_storage)
 
-            kwargs = {}
+            kwargs: dict[str, Any] = {}
             if not self._args.cache:
                 # We should only pass indexes if cache is disabled. Otherwise,
                 # only TransactionCacheStorage should have indexes.
@@ -252,14 +251,8 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             self.log.info('--x-enable-event-queue flag provided. '
                           'The events detected by the full node will be stored and can be retrieved by clients')
 
-        self.feature_service = FeatureService(
-            feature_settings=settings.FEATURE_ACTIVATION,
-            tx_storage=tx_storage
-        )
-
         bit_signaling_service = BitSignalingService(
-            feature_settings=settings.FEATURE_ACTIVATION,
-            feature_service=self.feature_service,
+            settings=settings,
             tx_storage=tx_storage,
             support_features=self._args.signal_support,
             not_support_features=self._args.signal_not_support,
@@ -274,11 +267,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
 
         daa = DifficultyAdjustmentAlgorithm(settings=settings, test_mode=test_mode)
 
-        vertex_verifiers = VertexVerifiers.create_defaults(
-            settings=settings,
-            daa=daa,
-            feature_service=self.feature_service
-        )
+        vertex_verifiers = VertexVerifiers.create_defaults(settings=settings, daa=daa)
         verification_service = VerificationService(
             verifiers=vertex_verifiers,
             tx_storage=tx_storage,
@@ -310,7 +299,6 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             verification_service=verification_service,
             consensus=consensus_algorithm,
             p2p_manager=p2p_manager,
-            feature_service=self.feature_service,
             pubsub=pubsub,
             wallet=self.wallet,
         )

hathor/builder/resources_builder.py

@@ -22,7 +22,6 @@
 
 from hathor.event.resources.event import EventResource
 from hathor.exception import BuilderError
-from hathor.feature_activation.feature_service import FeatureService
 from hathor.prometheus import PrometheusMetricsExporter
 
 if TYPE_CHECKING:
@@ -39,7 +38,6 @@ def __init__(
         manager: 'HathorManager',
         args: 'RunNodeArgs',
         event_ws_factory: Optional['EventWebsocketFactory'],
-        feature_service: FeatureService
     ) -> None:
         self.log = logger.new()
         self.manager = manager
@@ -50,8 +48,6 @@ def __init__(
         self._built_status = False
         self._built_prometheus = False
 
-        self._feature_service = feature_service
-
     def build(self) -> Optional[server.Site]:
         if self._args.prometheus:
             self.create_prometheus()
@@ -206,8 +202,7 @@ def create_resources(self) -> server.Site:
             (
                 b'feature',
                 FeatureResource(
-                    feature_settings=settings.FEATURE_ACTIVATION,
-                    feature_service=self._feature_service,
+                    settings=settings,
                     tx_storage=self.manager.tx_storage
                 ),
                 root

hathor/cli/mining.py

@@ -133,15 +133,13 @@ def execute(args: Namespace) -> None:
                                                                       block.nonce, block.weight))
 
         try:
-            from unittest.mock import Mock
-
             from hathor.conf.get_settings import get_global_settings
             from hathor.daa import DifficultyAdjustmentAlgorithm
             from hathor.verification.verification_service import VerificationService
             from hathor.verification.vertex_verifiers import VertexVerifiers
             settings = get_global_settings()
             daa = DifficultyAdjustmentAlgorithm(settings=settings)
-            verifiers = VertexVerifiers.create_defaults(settings=settings, daa=daa, feature_service=Mock())
+            verifiers = VertexVerifiers.create_defaults(settings=settings, daa=daa)
             verification_service = VerificationService(verifiers=verifiers, settings=settings)
             verification_service.verify_without_storage(block)
         except HathorError:

hathor/cli/run_node.py

@@ -199,7 +199,6 @@ def prepare(self, *, register_resources: bool = True) -> None:
                 self.manager,
                 self._args,
                 builder.event_ws_factory,
-                builder.feature_service
             )
             status_server = resources_builder.build()
             if self._args.status:
@@ -221,7 +220,6 @@ def prepare(self, *, register_resources: bool = True) -> None:
             wallet=self.manager.wallet,
             rocksdb_storage=getattr(builder, 'rocksdb_storage', None),
             stratum_factory=self.manager.stratum_factory,
-            feature_service=self.manager.vertex_handler._feature_service,
             bit_signaling_service=self.manager._bit_signaling_service,
         )
 

hathor/feature_activation/bit_signaling_service.py

@@ -14,11 +14,10 @@
 
 from structlog import get_logger
 
+from hathor.conf.settings import HathorSettings
 from hathor.feature_activation.feature import Feature
-from hathor.feature_activation.feature_service import FeatureService
 from hathor.feature_activation.model.criteria import Criteria
 from hathor.feature_activation.model.feature_state import FeatureState
-from hathor.feature_activation.settings import Settings as FeatureSettings
 from hathor.feature_activation.storage.feature_activation_storage import FeatureActivationStorage
 from hathor.transaction import Block
 from hathor.transaction.storage import TransactionStorage
@@ -29,8 +28,7 @@
 class BitSignalingService:
     __slots__ = (
         '_log',
-        '_feature_settings',
-        '_feature_service',
+        '_settings',
         '_tx_storage',
         '_support_features',
         '_not_support_features',
@@ -40,23 +38,20 @@ class BitSignalingService:
     def __init__(
         self,
         *,
-        feature_settings: FeatureSettings,
-        feature_service: FeatureService,
+        settings: HathorSettings,
         tx_storage: TransactionStorage,
         support_features: set[Feature],
         not_support_features: set[Feature],
         feature_storage: FeatureActivationStorage | None,
     ) -> None:
         self._log = logger.new()
-        self._feature_settings = feature_settings
-        self._feature_service = feature_service
+        self._settings = settings
         self._tx_storage = tx_storage
         self._support_features = support_features
         self._not_support_features = not_support_features
         self._feature_storage = feature_storage
 
         self._validate_support_intersection()
-        self._feature_service.bit_signaling_service = self
 
     def start(self) -> None:
         """
@@ -163,14 +158,14 @@ def _log_signal_bits(self, feature: Feature, enable_bit: bool, support: bool, no
 
     def _get_signaling_features(self, block: Block) -> dict[Feature, Criteria]:
         """Given a specific block, return all features that are in a signaling state for that block."""
-        feature_descriptions = self._feature_service.get_bits_description(block=block)
+        feature_infos = block.static_metadata.get_feature_info(self._settings)
         signaling_features = {
-            feature: description.criteria
-            for feature, description in feature_descriptions.items()
-            if description.state in FeatureState.get_signaling_states()
+            feature: feature_info.criteria
+            for feature, feature_info in feature_infos.items()
+            if feature_info.state in FeatureState.get_signaling_states()
         }
 
-        assert len(signaling_features) <= self._feature_settings.max_signal_bits, (
+        assert len(signaling_features) <= self._settings.FEATURE_ACTIVATION.max_signal_bits, (
             'Invalid state. Signaling more features than the allowed maximum.'
         )