refactor: create VertexHandler

Author: glevco

hathor/builder/builder.py

@@ -49,6 +49,7 @@
 from hathor.util import Random, get_environment_info, not_none
 from hathor.verification.verification_service import VerificationService
 from hathor.verification.vertex_verifiers import VertexVerifiers
+from hathor.vertex_handler import VertexHandler
 from hathor.wallet import BaseWallet, Wallet
 
 logger = get_logger()
@@ -156,6 +157,9 @@ def __init__(self) -> None:
         self._soft_voided_tx_ids: Optional[set[bytes]] = None
 
         self._execution_manager: ExecutionManager | None = None
+        self._vertex_handler: VertexHandler | None = None
+        self._consensus: ConsensusAlgorithm | None = None
+        self._p2p_manager: ConnectionsManager | None = None
 
     def build(self) -> BuildArtifacts:
         if self.artifacts is not None:
@@ -171,10 +175,9 @@ def build(self) -> BuildArtifacts:
         peer_id = self._get_peer_id()
 
         execution_manager = self._get_or_create_execution_manager()
-        soft_voided_tx_ids = self._get_soft_voided_tx_ids()
-        consensus_algorithm = ConsensusAlgorithm(soft_voided_tx_ids, pubsub, execution_manager=execution_manager)
+        consensus_algorithm = self._get_or_create_consensus()
 
-        p2p_manager = self._get_p2p_manager()
+        p2p_manager = self._get_or_create_p2p_manager()
 
         wallet = self._get_or_create_wallet()
         event_manager = self._get_or_create_event_manager()
@@ -185,6 +188,7 @@ def build(self) -> BuildArtifacts:
         verification_service = self._get_or_create_verification_service()
         daa = self._get_or_create_daa()
         cpu_mining_service = self._get_or_create_cpu_mining_service()
+        vertex_handler = self._get_or_create_vertex_handler()
 
         if self._enable_address_index:
             indexes.enable_address_index(pubsub)
@@ -219,11 +223,11 @@ def build(self) -> BuildArtifacts:
             checkpoints=self._checkpoints,
             capabilities=self._capabilities,
             environment_info=get_environment_info(self._cmdline, peer_id.id),
-            feature_service=feature_service,
             bit_signaling_service=bit_signaling_service,
             verification_service=verification_service,
             cpu_mining_service=cpu_mining_service,
             execution_manager=execution_manager,
+            vertex_handler=vertex_handler,
             **kwargs
         )
 
@@ -323,6 +327,15 @@ def _get_or_create_execution_manager(self) -> ExecutionManager:
 
         return self._execution_manager
 
+    def _get_or_create_consensus(self) -> ConsensusAlgorithm:
+        if self._consensus is None:
+            soft_voided_tx_ids = self._get_soft_voided_tx_ids()
+            pubsub = self._get_or_create_pubsub()
+            execution_manager = self._get_or_create_execution_manager()
+            self._consensus = ConsensusAlgorithm(soft_voided_tx_ids, pubsub, execution_manager=execution_manager)
+
+        return self._consensus
+
     def _get_or_create_pubsub(self) -> PubSubManager:
         if self._pubsub is None:
             self._pubsub = PubSubManager(self._get_reactor())
@@ -351,7 +364,10 @@ def _get_or_create_rocksdb_storage(self) -> RocksDBStorage:
 
         return self._rocksdb_storage
 
-    def _get_p2p_manager(self) -> ConnectionsManager:
+    def _get_or_create_p2p_manager(self) -> ConnectionsManager:
+        if self._p2p_manager:
+            return self._p2p_manager
+
         from hathor.p2p.sync_v1.factory import SyncV11Factory
         from hathor.p2p.sync_v2.factory import SyncV2Factory
         from hathor.p2p.sync_version import SyncVersion
@@ -362,7 +378,7 @@ def _get_p2p_manager(self) -> ConnectionsManager:
 
         assert self._network is not None
 
-        p2p_manager = ConnectionsManager(
+        self._p2p_manager = ConnectionsManager(
             reactor,
             network=self._network,
             my_peer=my_peer,
@@ -371,13 +387,13 @@ def _get_p2p_manager(self) -> ConnectionsManager:
             whitelist_only=False,
             rng=self._rng,
         )
-        p2p_manager.add_sync_factory(SyncVersion.V1_1, SyncV11Factory(p2p_manager))
-        p2p_manager.add_sync_factory(SyncVersion.V2, SyncV2Factory(p2p_manager))
+        self._p2p_manager.add_sync_factory(SyncVersion.V1_1, SyncV11Factory(self._p2p_manager))
+        self._p2p_manager.add_sync_factory(SyncVersion.V2, SyncV2Factory(self._p2p_manager))
         if self._enable_sync_v1:
-            p2p_manager.enable_sync_version(SyncVersion.V1_1)
+            self._p2p_manager.enable_sync_version(SyncVersion.V1_1)
         if self._enable_sync_v2:
-            p2p_manager.enable_sync_version(SyncVersion.V2)
-        return p2p_manager
+            self._p2p_manager.enable_sync_version(SyncVersion.V2)
+        return self._p2p_manager
 
     def _get_or_create_indexes_manager(self) -> IndexesManager:
         if self._indexes_manager is not None:
@@ -536,6 +552,22 @@ def _get_or_create_cpu_mining_service(self) -> CpuMiningService:
 
         return self._cpu_mining_service
 
+    def _get_or_create_vertex_handler(self) -> VertexHandler:
+        if self._vertex_handler is None:
+            self._vertex_handler = VertexHandler(
+                reactor=self._get_reactor(),
+                settings=self._get_or_create_settings(),
+                tx_storage=self._get_or_create_tx_storage(),
+                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(),
+            )
+
+        return self._vertex_handler
+
     def use_memory(self) -> 'Builder':
         self.check_if_can_modify()
         self._storage_type = StorageType.MEMORY
@@ -565,16 +597,14 @@ def force_memory_index(self) -> 'Builder':
 
     def _get_or_create_wallet(self) -> Optional[BaseWallet]:
         if self._wallet is not None:
-            assert self._wallet_directory is None
-            assert self._wallet_unlock is None
             return self._wallet
 
         if self._wallet_directory is None:
             return None
-        wallet = Wallet(directory=self._wallet_directory)
+        self._wallet = Wallet(directory=self._wallet_directory)
         if self._wallet_unlock is not None:
-            wallet.unlock(self._wallet_unlock)
-        return wallet
+            self._wallet.unlock(self._wallet_unlock)
+        return self._wallet
 
     def set_wallet(self, wallet: BaseWallet) -> 'Builder':
         self.check_if_can_modify()

hathor/builder/cli_builder.py

@@ -43,6 +43,7 @@
 from hathor.util import Random, not_none
 from hathor.verification.verification_service import VerificationService
 from hathor.verification.vertex_verifiers import VertexVerifiers
+from hathor.vertex_handler import VertexHandler
 from hathor.wallet import BaseWallet, HDWallet, Wallet
 
 logger = get_logger()
@@ -300,6 +301,18 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
         if enable_sync_v2:
             p2p_manager.enable_sync_version(SyncVersion.V2)
 
+        vertex_handler = VertexHandler(
+            reactor=reactor,
+            settings=settings,
+            tx_storage=tx_storage,
+            verification_service=verification_service,
+            consensus=consensus_algorithm,
+            p2p_manager=p2p_manager,
+            feature_service=self.feature_service,
+            pubsub=pubsub,
+            wallet=self.wallet,
+        )
+
         self.manager = HathorManager(
             reactor,
             settings=settings,
@@ -317,11 +330,11 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             environment_info=get_environment_info(args=str(self._args), peer_id=peer_id.id),
             full_verification=full_verification,
             enable_event_queue=self._args.x_enable_event_queue,
-            feature_service=self.feature_service,
             bit_signaling_service=bit_signaling_service,
             verification_service=verification_service,
             cpu_mining_service=cpu_mining_service,
             execution_manager=execution_manager,
+            vertex_handler=vertex_handler,
         )
 
         if self._args.x_ipython_kernel:

hathor/cli/db_import.py

@@ -88,7 +88,7 @@ def _import_txs(self) -> Iterator['BaseTransaction']:
             assert tx is not None
             assert tx.hash is not None
             tx.storage = self.tx_storage
-            self.manager.on_new_tx(tx, quiet=True, fails_silently=False, skip_block_weight_verification=True)
+            self.manager.on_new_tx(tx, quiet=True, fails_silently=False)
             yield tx
 
 

hathor/cli/run_node.py

@@ -221,7 +221,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,
+            feature_service=self.manager.vertex_handler._feature_service,
             bit_signaling_service=self.manager._bit_signaling_service,
         )