refactor(metadata): move metadata attributes to static metadata

Author: glevco

hathor/builder/builder.py

@@ -532,7 +532,12 @@ def _get_or_create_verification_service(self) -> VerificationService:
         if self._verification_service is None:
             verifiers = self._get_or_create_vertex_verifiers()
             storage = self._get_or_create_tx_storage()
-            self._verification_service = VerificationService(verifiers=verifiers, tx_storage=storage)
+            settings = self._get_or_create_settings()
+            self._verification_service = VerificationService(
+                verifiers=verifiers,
+                tx_storage=storage,
+                settings=settings,
+            )
 
         return self._verification_service
 

hathor/builder/cli_builder.py

@@ -284,7 +284,11 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             daa=daa,
             feature_service=self.feature_service
         )
-        verification_service = VerificationService(verifiers=vertex_verifiers, tx_storage=tx_storage)
+        verification_service = VerificationService(
+            verifiers=vertex_verifiers,
+            tx_storage=tx_storage,
+            settings=settings,
+        )
 
         cpu_mining_service = CpuMiningService()
 

hathor/cli/mining.py

@@ -142,7 +142,7 @@ def execute(args: Namespace) -> None:
             settings = get_global_settings()
             daa = DifficultyAdjustmentAlgorithm(settings=settings)
             verifiers = VertexVerifiers.create_defaults(settings=settings, daa=daa, feature_service=Mock())
-            verification_service = VerificationService(verifiers=verifiers)
+            verification_service = VerificationService(verifiers=verifiers, settings=settings)
             verification_service.verify_without_storage(block)
         except HathorError:
             print('[{}] ERROR: Block has not been pushed because it is not valid.'.format(datetime.datetime.now()))

hathor/event/model/event_data.py

@@ -120,6 +120,7 @@ def from_event_arguments(cls, args: EventArguments) -> 'TxData':
         tx_extra_data_json = get_tx_extra_data(args.tx, detail_tokens=False)
         tx_json = tx_extra_data_json['tx']
         meta_json = tx_extra_data_json['meta']
+        meta_json['height'] = meta_json.get('height', 0)  # TODO: Improve event model to reflect static metadata
         tx_json['metadata'] = meta_json
         tx_json['outputs'] = [
             output | dict(decoded=output['decoded'] or None)

hathor/feature_activation/feature_service.py

@@ -60,8 +60,8 @@ def is_signaling_mandatory_features(self, block: 'Block') -> BlockSignalingState
         Return whether a block is signaling features that are mandatory, that is, any feature currently in the
         MUST_SIGNAL phase.
         """
-        bit_counts = block.get_feature_activation_bit_counts()
-        height = block.get_height()
+        bit_counts = block.static_metadata.feature_activation_bit_counts
+        height = block.static_metadata.height
         offset_to_boundary = height % self._feature_settings.evaluation_interval
         remaining_blocks = self._feature_settings.evaluation_interval - offset_to_boundary - 1
         descriptions = self.get_bits_description(block=block)
@@ -95,7 +95,7 @@ def get_state(self, *, block: 'Block', feature: Feature) -> FeatureState:
         # All blocks within the same evaluation interval have the same state, that is, the state is only defined for
         # the block in each interval boundary. Therefore, we get the state of the previous boundary block or calculate
         # a new state if this block is a boundary block.
-        height = block.get_height()
+        height = block.static_metadata.height
         offset_to_boundary = height % self._feature_settings.evaluation_interval
         offset_to_previous_boundary = offset_to_boundary or self._feature_settings.evaluation_interval
         previous_boundary_height = height - offset_to_previous_boundary
@@ -139,7 +139,7 @@ def _calculate_new_state(
         an AssertionError. Non-boundary blocks never calculate their own state, they get it from their parent block
         instead.
         """
-        height = boundary_block.get_height()
+        height = boundary_block.static_metadata.height
         criteria = self._feature_settings.features.get(feature)
         evaluation_interval = self._feature_settings.evaluation_interval
 
@@ -162,7 +162,7 @@ def _calculate_new_state(
             # Get the count for this block's parent. Since this is a boundary block, its parent count represents the
             # previous evaluation interval count.
             parent_block = boundary_block.get_block_parent()
-            counts = parent_block.get_feature_activation_bit_counts()
+            counts = parent_block.static_metadata.feature_activation_bit_counts
             count = counts[criteria.bit]
             threshold = criteria.get_threshold(self._feature_settings)
 
@@ -209,8 +209,9 @@ def _get_ancestor_at_height(self, *, block: 'Block', ancestor_height: int) -> 'B
         Given a block, return its ancestor at a specific height.
         Uses the height index if the block is in the best blockchain, or search iteratively otherwise.
         """
-        assert ancestor_height < block.get_height(), (
-            f"ancestor height must be lower than the block's height: {ancestor_height} >= {block.get_height()}"
+        assert ancestor_height < block.static_metadata.height, (
+            f"ancestor height must be lower than the block's height: "
+            f"{ancestor_height} >= {block.static_metadata.height}"
         )
 
         # It's possible that this method is called before the consensus runs for this block, therefore we do not know
@@ -219,7 +220,7 @@ def _get_ancestor_at_height(self, *, block: 'Block', ancestor_height: int) -> 'B
         parent_metadata = parent_block.get_metadata()
         assert parent_metadata.validation.is_fully_connected(), 'The parent should always be fully validated.'
 
-        if parent_block.get_height() == ancestor_height:
+        if parent_block.static_metadata.height == ancestor_height:
             return parent_block
 
         if not parent_metadata.voided_by and (ancestor := self._tx_storage.get_block_by_height(ancestor_height)):
@@ -237,11 +238,11 @@ def _get_ancestor_iteratively(self, *, block: 'Block', ancestor_height: int) ->
         # 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.
         assert ancestor_height >= 0
-        assert block.get_height() - ancestor_height <= self._feature_settings.evaluation_interval, (
+        assert block.static_metadata.height - ancestor_height <= self._feature_settings.evaluation_interval, (
             'requested ancestor is deeper than the maximum allowed'
         )
         ancestor = block
-        while ancestor.get_height() > ancestor_height:
+        while ancestor.static_metadata.height > ancestor_height:
             ancestor = ancestor.get_block_parent()
 
         return ancestor

hathor/feature_activation/resources/feature.py

@@ -89,7 +89,7 @@ def get_block_features(self, request: Request) -> bytes:
 
     def get_features(self) -> bytes:
         best_block = self.tx_storage.get_best_block()
-        bit_counts = best_block.get_feature_activation_bit_counts()
+        bit_counts = best_block.static_metadata.feature_activation_bit_counts
         features = []
 
         for feature, criteria in self._feature_settings.features.items():

hathor/manager.py

@@ -435,7 +435,7 @@ def _initialize_components_full_verification(self) -> None:
             dt = LogDuration(t2 - t1)
             dcnt = cnt - cnt2
             tx_rate = '?' if dt == 0 else dcnt / dt
-            h = max(h, tx_meta.height or 0)
+            h = max(h, (tx.static_metadata.height if isinstance(tx, Block) else 0))
             if dt > 30:
                 ts_date = datetime.datetime.fromtimestamp(self.tx_storage.latest_timestamp)
                 if h == 0:
@@ -455,12 +455,10 @@ def _initialize_components_full_verification(self) -> None:
 
             try:
                 # TODO: deal with invalid tx
-                tx.calculate_height()
                 tx._update_parents_children_metadata()
 
                 if tx.can_validate_full():
                     tx.update_initial_metadata()
-                    tx.calculate_min_height()
                     if tx.is_genesis:
                         assert tx.validate_checkpoint(self.checkpoints)
                     assert self.verification_service.validate_full(
@@ -560,8 +558,6 @@ def _initialize_components_new(self) -> None:
         self.tx_storage.pre_init()
         assert self.tx_storage.indexes is not None
 
-        self._bit_signaling_service.start()
-
         started_at = int(time.time())
         last_started_at = self.tx_storage.get_last_started_at()
         if last_started_at >= started_at:
@@ -577,6 +573,8 @@ def _initialize_components_new(self) -> None:
         #       complex code
         self.tx_storage.indexes._manually_initialize(self.tx_storage)
 
+        self._bit_signaling_service.start()
+
         # Verify if all checkpoints that exist in the database are correct
         try:
             self._verify_checkpoints()

hathor/mining/block_template.py

@@ -68,7 +68,7 @@ def generate_mining_block(self, rng: Random, merge_mined: bool = False, address:
         block = cls(outputs=tx_outputs, parents=parents, timestamp=block_timestamp,
                     data=data or b'', storage=storage, weight=self.weight, signal_bits=self.signal_bits)
         if include_metadata:
-            block._metadata = TransactionMetadata(height=self.height, score=self.score)
+            block._metadata = TransactionMetadata(score=self.score)
         block.get_metadata(use_storage=False)
         return block
 

hathor/p2p/resources/mining_info.py

@@ -49,8 +49,9 @@ def render_GET(self, request):
             self._settings.P2PKH_VERSION_BYTE.hex() + 'acbfb94571417423c1ed66f706730c4aea516ac5762cccb8'
         )
         block = self.manager.generate_mining_block(address=burn_address)
+        block.init_static_metadata_from_storage(self._settings, self.manager.tx_storage)
 
-        height = block.calculate_height() - 1
+        height = block.static_metadata.height - 1
         difficulty = max(int(Weight(block.weight).to_pdiff()), 1)
 
         parent = block.get_block_parent()

hathor/stratum/stratum.py

@@ -672,6 +672,7 @@ def create_job_tx(self, jobid: UUID) -> BaseTransaction:
         data = data[:self._settings.BLOCK_DATA_MAX_SIZE]
         block = self.manager.generate_mining_block(data=data, address=self.miner_address,
                                                    merge_mined=self.merged_mining)
+        block.init_static_metadata_from_storage(self._settings, self.manager.tx_storage)
         self.log.debug('prepared block for mining', block=block)
         return block
 

hathor/transaction/base_transaction.py

@@ -22,12 +22,13 @@
 from itertools import chain
 from math import inf, isfinite, log
 from struct import error as StructError, pack
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterator, Optional, TypeAlias, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterator, Optional, TypeAlias, TypeVar
 
 from structlog import get_logger
 
 from hathor.checkpoint import Checkpoint
 from hathor.conf.get_settings import get_global_settings
+from hathor.conf.settings import HathorSettings
 from hathor.transaction.exceptions import InvalidOutputValue, WeightError
 from hathor.transaction.static_metadata import VertexStaticMetadata
 from hathor.transaction.transaction_metadata import TransactionMetadata
@@ -272,14 +273,6 @@ def __bytes__(self) -> bytes:
     def __hash__(self) -> int:
         return hash(self.hash)
 
-    @abstractmethod
-    def calculate_height(self) -> int:
-        raise NotImplementedError
-
-    @abstractmethod
-    def calculate_min_height(self) -> int:
-        raise NotImplementedError
-
     @property
     def hash(self) -> VertexId:
         assert self._hash is not None, 'Vertex hash must be initialized.'
@@ -624,19 +617,11 @@ def get_metadata(self, *, force_reload: bool = False, use_storage: bool = True)
             metadata = self.storage.get_metadata(self.hash)
             self._metadata = metadata
         if not metadata:
-            # FIXME: there is code that set use_storage=False but relies on correct height being calculated
-            #        which requires the use of a storage, this is a workaround that should be fixed, places where this
-            #        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
-            min_height = 0 if self.is_genesis else None
-
             metadata = TransactionMetadata(
                 hash=self._hash,
                 accumulated_weight=self.weight,
-                height=height,
                 score=score,
-                min_height=min_height
             )
             self._metadata = metadata
         if not metadata.hash:
@@ -662,8 +647,6 @@ def reset_metadata(self) -> None:
             self._metadata.voided_by = {self._settings.PARTIALLY_VALIDATED_ID}
         self._metadata._tx_ref = weakref.ref(self)
 
-        self._update_height_metadata()
-
         self.storage.save_transaction(self, only_metadata=True)
 
     def update_accumulated_weight(self, *, stop_value: float = inf, save_file: bool = True) -> TransactionMetadata:
@@ -717,28 +700,12 @@ def update_initial_metadata(self, *, save: bool = True) -> None:
 
         It is called when a new transaction/block is received by HathorManager.
         """
-        self._update_height_metadata()
         self._update_parents_children_metadata()
-        self.update_reward_lock_metadata()
-        self._update_feature_activation_bit_counts()
         self._update_initial_accumulated_weight()
         if save:
             assert self.storage is not None
             self.storage.save_transaction(self, only_metadata=True)
 
-    def _update_height_metadata(self) -> None:
-        """Update the vertice height metadata."""
-        meta = self.get_metadata()
-        meta.height = self.calculate_height()
-
-    def update_reward_lock_metadata(self) -> None:
-        """Update the txs/block min_height metadata."""
-        metadata = self.get_metadata()
-        min_height = self.calculate_min_height()
-        if metadata.min_height is not None:
-            assert metadata.min_height == min_height
-        metadata.min_height = min_height
-
     def _update_parents_children_metadata(self) -> None:
         """Update the txs/block parent's children metadata."""
         assert self._hash is not None
@@ -750,15 +717,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(self) -> None:
-        """Update the block's feature_activation_bit_counts."""
-        if not self.is_block:
-            return
-        from hathor.transaction import Block
-        assert isinstance(self, Block)
-        # This method lazily calculates and stores the value in metadata
-        cast(Block, self).get_feature_activation_bit_counts()
-
     def _update_initial_accumulated_weight(self) -> None:
         """Update the vertex initial accumulated_weight."""
         metadata = self.get_metadata()
@@ -901,7 +859,7 @@ def static_metadata(self) -> StaticMetadataT:
         return self._static_metadata
 
     @abstractmethod
-    def init_static_metadata_from_storage(self, storage: 'TransactionStorage') -> None:
+    def init_static_metadata_from_storage(self, settings: HathorSettings, storage: 'TransactionStorage') -> None:
         """Initialize this vertex's static metadata using dependencies from a storage. This can be called multiple
         times, provided the dependencies didn't change."""
         raise NotImplementedError
@@ -916,7 +874,8 @@ def set_static_metadata(self, static_metadata: StaticMetadataT | None) -> None:
 
 """
 Type aliases for easily working with `GenericVertex`. A `Vertex` is a superclass that includes all specific
-vertex subclasses, and a `BaseTransaction` is simply an alias to `Vertex` for backwards compatibility.
+vertex subclasses, and a `BaseTransaction` is simply an alias to `Vertex` for backwards compatibility (it can be
+removed in the future).
 """
 Vertex: TypeAlias = GenericVertex[VertexStaticMetadata]
 BaseTransaction: TypeAlias = Vertex