feat(feature-activation): implement must signal

Author: glevco

hathor/builder/builder.py

@@ -63,6 +63,7 @@ class BuildArtifacts(NamedTuple):
     pubsub: PubSubManager
     consensus: ConsensusAlgorithm
     tx_storage: TransactionStorage
+    feature_service: FeatureService
     indexes: Optional[IndexesManager]
     wallet: Optional[BaseWallet]
     rocksdb_storage: Optional[RocksDBStorage]
@@ -144,7 +145,7 @@ def build(self) -> BuildArtifacts:
         if self._network is None:
             raise TypeError('you must set a network')
 
-        settings = self._get_or_create_settings()
+        settings = self.get_or_create_settings()
         reactor = self._get_reactor()
         pubsub = self._get_or_create_pubsub()
 
@@ -158,9 +159,9 @@ def build(self) -> BuildArtifacts:
         wallet = self._get_or_create_wallet()
         event_manager = self._get_or_create_event_manager()
         indexes = self._get_or_create_indexes_manager()
-        tx_storage = self._get_or_create_tx_storage(indexes)
-        feature_service = self._get_or_create_feature_service(tx_storage)
-        bit_signaling_service = self._get_or_create_bit_signaling_service(tx_storage)
+        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()
 
         if self._enable_address_index:
@@ -221,6 +222,7 @@ def build(self) -> BuildArtifacts:
             wallet=wallet,
             rocksdb_storage=self._rocksdb_storage,
             stratum_factory=stratum_factory,
+            feature_service=feature_service,
         )
 
         return self.artifacts
@@ -264,7 +266,7 @@ def set_peer_id(self, peer_id: PeerId) -> 'Builder':
         self._peer_id = peer_id
         return self
 
-    def _get_or_create_settings(self) -> HathorSettingsType:
+    def get_or_create_settings(self) -> HathorSettingsType:
         if self._settings is None:
             self._settings = get_settings()
         return self._settings
@@ -278,7 +280,7 @@ def _get_soft_voided_tx_ids(self) -> set[bytes]:
         if self._soft_voided_tx_ids is not None:
             return self._soft_voided_tx_ids
 
-        settings = self._get_or_create_settings()
+        settings = self.get_or_create_settings()
 
         return set(settings.SOFT_VOIDED_TX_IDS)
 
@@ -352,7 +354,9 @@ def _get_or_create_indexes_manager(self) -> IndexesManager:
 
         return self._indexes_manager
 
-    def _get_or_create_tx_storage(self, indexes: IndexesManager) -> TransactionStorage:
+    def _get_or_create_tx_storage(self) -> TransactionStorage:
+        indexes = self._get_or_create_indexes_manager()
+
         if self._tx_storage is not None:
             # If a tx storage is provided, set the indexes manager to it.
             self._tx_storage.indexes = indexes
@@ -408,22 +412,25 @@ def _get_or_create_event_manager(self) -> EventManager:
 
         return self._event_manager
 
-    def _get_or_create_feature_service(self, tx_storage: TransactionStorage) -> FeatureService:
+    def get_or_create_feature_service(self) -> FeatureService:
         if self._feature_service is None:
-            settings = self._get_or_create_settings()
+            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, tx_storage: TransactionStorage) -> BitSignalingService:
+    def _get_or_create_bit_signaling_service(self) -> BitSignalingService:
         if self._bit_signaling_service is None:
-            settings = self._get_or_create_settings()
+            settings = self.get_or_create_settings()
+            tx_storage = self._get_or_create_tx_storage()
+            feature_service = self.get_or_create_feature_service()
             self._bit_signaling_service = BitSignalingService(
                 feature_settings=settings.FEATURE_ACTIVATION,
-                feature_service=self._get_or_create_feature_service(tx_storage),
+                feature_service=feature_service,
                 tx_storage=tx_storage,
                 support_features=self._support_features,
                 not_support_features=self._not_support_features,
@@ -440,8 +447,9 @@ def _get_or_create_verification_service(self) -> VerificationService:
 
     def _get_or_create_vertex_verifiers(self) -> VertexVerifiers:
         if self._vertex_verifiers is None:
-            settings = self._get_or_create_settings()
-            self._vertex_verifiers = VertexVerifiers.create(settings=settings)
+            settings = self.get_or_create_settings()
+            feature_service = self.get_or_create_feature_service()
+            self._vertex_verifiers = VertexVerifiers.create(settings=settings, feature_service=feature_service)
 
         return self._vertex_verifiers
 

hathor/builder/cli_builder.py

@@ -203,7 +203,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             not_support_features=self._args.signal_not_support
         )
 
-        vertex_verifiers = VertexVerifiers.create(settings=settings)
+        vertex_verifiers = VertexVerifiers.create(settings=settings, feature_service=self.feature_service)
         verification_service = VerificationService(verifiers=vertex_verifiers)
 
         p2p_manager = ConnectionsManager(

hathor/cli/run_node.py

@@ -191,6 +191,7 @@ 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._feature_service
         )
 
     def start_sentry_if_possible(self) -> None:

hathor/feature_activation/feature_service.py

@@ -12,28 +12,54 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from typing import TYPE_CHECKING
+
 from hathor.feature_activation.feature import Feature
 from hathor.feature_activation.model.feature_description import FeatureDescription
 from hathor.feature_activation.model.feature_state import FeatureState
 from hathor.feature_activation.settings import Settings as FeatureSettings
-from hathor.transaction import Block
-from hathor.transaction.storage import TransactionStorage
+
+if TYPE_CHECKING:
+    from hathor.transaction import Block
+    from hathor.transaction.storage import TransactionStorage
 
 
 class FeatureService:
     __slots__ = ('_feature_settings', '_tx_storage')
 
-    def __init__(self, *, feature_settings: FeatureSettings, tx_storage: TransactionStorage) -> None:
+    def __init__(self, *, feature_settings: FeatureSettings, tx_storage: 'TransactionStorage') -> None:
         self._feature_settings = feature_settings
         self._tx_storage = tx_storage
 
-    def is_feature_active(self, *, block: Block, feature: Feature) -> bool:
+    def is_feature_active(self, *, block: 'Block', feature: Feature) -> bool:
         """Returns whether a Feature is active at a certain block."""
         state = self.get_state(block=block, feature=feature)
 
         return state == FeatureState.ACTIVE
 
-    def get_state(self, *, block: Block, feature: Feature) -> FeatureState:
+    def check_must_signal(self, block: 'Block') -> bool:
+        descriptions = self.get_bits_description(block=block)
+
+        for feature, description in descriptions.items():
+            criteria = self._feature_settings.features[feature]
+
+            if description.state is FeatureState.MUST_SIGNAL:
+                # TODO: make functions
+                counts = block.get_feature_activation_bit_counts()
+                count = counts[criteria.bit]
+                threshold = criteria.get_threshold(self._feature_settings)
+                missing_signals = threshold - count
+                height = block.get_height()
+                # TODO: Check edges
+                offset_to_boundary = height % self._feature_settings.evaluation_interval
+                remaining_blocks = self._feature_settings.evaluation_interval - offset_to_boundary - 1
+
+                if missing_signals > remaining_blocks:
+                    return True
+
+        return False
+
+    def get_state(self, *, block: 'Block', feature: Feature) -> FeatureState:
         """Returns the state of a feature at a certain block. Uses block metadata to cache states."""
 
         # per definition, the genesis block is in the DEFINED state for all features
@@ -54,6 +80,10 @@ def get_state(self, *, block: Block, feature: Feature) -> FeatureState:
         previous_boundary_block = self._get_ancestor_at_height(block=block, height=previous_boundary_height)
         previous_boundary_state = self.get_state(block=previous_boundary_block, feature=feature)
 
+        # Instead of caching the current block we cache the previous boundary block, as the current block may not
+        # be verified yet, so we cannot persist its metadata.
+        previous_boundary_block.set_feature_state(feature=feature, state=previous_boundary_state, save=True)
+
         if offset_to_boundary != 0:
             return previous_boundary_state
 
@@ -63,14 +93,14 @@ def get_state(self, *, block: Block, feature: Feature) -> FeatureState:
             previous_state=previous_boundary_state
         )
 
-        block.update_feature_state(feature=feature, state=new_state)
+        block.set_feature_state(feature=feature, state=new_state)
 
         return new_state
 
     def _calculate_new_state(
         self,
         *,
-        boundary_block: Block,
+        boundary_block: 'Block',
         feature: Feature,
         previous_state: FeatureState
     ) -> FeatureState:
@@ -136,7 +166,7 @@ def _calculate_new_state(
 
         raise ValueError(f'Unknown previous state: {previous_state}')
 
-    def get_bits_description(self, *, block: Block) -> dict[Feature, FeatureDescription]:
+    def get_bits_description(self, *, block: 'Block') -> dict[Feature, FeatureDescription]:
         """Returns the criteria definition and feature state for all features at a certain block."""
         return {
             feature: FeatureDescription(
@@ -146,7 +176,7 @@ def get_bits_description(self, *, block: Block) -> dict[Feature, FeatureDescript
             for feature, criteria in self._feature_settings.features.items()
         }
 
-    def _get_ancestor_at_height(self, *, block: Block, height: int) -> Block:
+    def _get_ancestor_at_height(self, *, block: 'Block', height: int) -> 'Block':
         """
         Given a block, returns its ancestor at a specific height.
         Uses the height index if the block is in the best blockchain, or search iteratively otherwise.
@@ -158,13 +188,14 @@ def _get_ancestor_at_height(self, *, block: Block, height: int) -> Block:
         metadata = block.get_metadata()
 
         if not metadata.voided_by and (ancestor := self._tx_storage.get_transaction_by_height(height)):
+            from hathor.transaction import Block
             assert isinstance(ancestor, Block)
             return ancestor
 
         return _get_ancestor_iteratively(block=block, ancestor_height=height)
 
 
-def _get_ancestor_iteratively(*, block: Block, ancestor_height: int) -> Block:
+def _get_ancestor_iteratively(*, block: 'Block', ancestor_height: int) -> 'Block':
     """Given a block, returns its ancestor at a specific height by iterating over its ancestors. This is slow."""
     # TODO: there are further optimizations to be done here, the latest common block height could be persisted in
     #  metadata, so we could still use the height index if the requested height is before that height.

hathor/simulator/simulator.py

@@ -21,7 +21,6 @@
 from structlog import get_logger
 
 from hathor.builder import BuildArtifacts, Builder
-from hathor.conf.get_settings import get_settings
 from hathor.daa import TestMode, _set_test_mode
 from hathor.manager import HathorManager
 from hathor.p2p.peer_id import PeerId
@@ -114,7 +113,6 @@ def __init__(self, seed: Optional[int] = None):
             seed = secrets.randbits(64)
         self.seed = seed
         self.rng = Random(self.seed)
-        self.settings = get_settings()
         self._network = 'testnet'
         self._clock = MemoryReactorHeapClock()
         self._peers: OrderedDict[str, HathorManager] = OrderedDict()
@@ -169,17 +167,25 @@ def create_artifacts(self, builder: Optional[Builder] = None) -> BuildArtifacts:
         wallet = HDWallet(gap_limit=2)
         wallet._manually_initialize()
 
+        builder = builder \
+            .set_reactor(self._clock) \
+            .set_rng(Random(self.rng.getrandbits(64))) \
+            .set_wallet(wallet)
+
+        feature_service = builder.get_or_create_feature_service()
+        settings = builder.get_or_create_settings()
+
         vertex_verifiers = VertexVerifiers(
-            block=SimulatorBlockVerifier(settings=self.settings),
-            merge_mined_block=SimulatorMergeMinedBlockVerifier(settings=self.settings),
-            tx=SimulatorTransactionVerifier(settings=self.settings),
-            token_creation_tx=SimulatorTokenCreationTransactionVerifier(settings=self.settings),
+            block=SimulatorBlockVerifier(settings=settings, feature_service=feature_service),
+            merge_mined_block=SimulatorMergeMinedBlockVerifier(
+                settings=settings,
+                feature_service=feature_service
+            ),
+            tx=SimulatorTransactionVerifier(settings=settings),
+            token_creation_tx=SimulatorTokenCreationTransactionVerifier(settings=settings),
         )
 
         artifacts = builder \
-            .set_reactor(self._clock) \
-            .set_rng(Random(self.rng.getrandbits(64))) \
-            .set_wallet(wallet) \
             .set_vertex_verifiers(vertex_verifiers) \
             .build()
 

hathor/transaction/base_transaction.py

@@ -672,20 +672,13 @@ def get_metadata(self, *, force_reload: bool = False, use_storage: bool = True)
             #        happens include generating new mining blocks and some tests
             height = self.calculate_height() if self.storage else None
             score = self.weight if self.is_genesis else 0
-            kwargs: dict[str, Any] = {}
-
-            if self.is_block:
-                from hathor.transaction import Block
-                assert isinstance(self, Block)
-                kwargs['feature_activation_bit_counts'] = self.calculate_feature_activation_bit_counts()
 
             metadata = TransactionMetadata(
                 hash=self.hash,
                 accumulated_weight=self.weight,
                 height=height,
                 score=score,
                 min_height=0,
-                **kwargs
             )
             self._metadata = metadata
         if not metadata.hash:
@@ -769,7 +762,6 @@ def update_initial_metadata(self, *, save: bool = True) -> None:
         self._update_height_metadata()
         self._update_parents_children_metadata()
         self._update_reward_lock_metadata()
-        self._update_feature_activation_bit_counts_metadata()
         if save:
             assert self.storage is not None
             self.storage.save_transaction(self, only_metadata=True)
@@ -795,16 +787,6 @@ def _update_parents_children_metadata(self) -> None:
                 metadata.children.append(self.hash)
                 self.storage.save_transaction(parent, only_metadata=True)
 
-    def _update_feature_activation_bit_counts_metadata(self) -> None:
-        """Update the block feature_activation_bit_counts metadata."""
-        if not self.is_block:
-            return
-
-        from hathor.transaction import Block
-        assert isinstance(self, Block)
-        metadata = self.get_metadata()
-        metadata.feature_activation_bit_counts = self.calculate_feature_activation_bit_counts()
-
     def update_timestamp(self, now: int) -> None:
         """Update this tx's timestamp