refactor(verification): move vertex verification to its own service

Author: glevco

hathor/builder/builder.py

@@ -41,6 +41,7 @@
     TransactionStorage,
 )
 from hathor.util import Random, Reactor, get_environment_info
+from hathor.verification.verification_service import VerificationService
 from hathor.wallet import BaseWallet, Wallet
 
 logger = get_logger()
@@ -101,6 +102,8 @@ def __init__(self) -> None:
         self._feature_service: Optional[FeatureService] = None
         self._bit_signaling_service: Optional[BitSignalingService] = None
 
+        self._verification_service: Optional[VerificationService] = None
+
         self._rocksdb_path: Optional[str] = None
         self._rocksdb_storage: Optional[RocksDBStorage] = None
         self._rocksdb_cache_capacity: Optional[int] = None
@@ -157,6 +160,7 @@ def build(self) -> BuildArtifacts:
         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)
+        verification_service = self._get_or_create_verification_service()
 
         if self._enable_address_index:
             indexes.enable_address_index(pubsub)
@@ -191,6 +195,7 @@ def build(self) -> BuildArtifacts:
             environment_info=get_environment_info(self._cmdline, peer_id.id),
             feature_service=feature_service,
             bit_signaling_service=bit_signaling_service,
+            verification_service=verification_service,
             **kwargs
         )
 
@@ -424,6 +429,12 @@ def _get_or_create_bit_signaling_service(self, tx_storage: TransactionStorage) -
 
         return self._bit_signaling_service
 
+    def _get_or_create_verification_service(self) -> VerificationService:
+        if self._verification_service is None:
+            self._verification_service = VerificationService()
+
+        return self._verification_service
+
     def use_memory(self) -> 'Builder':
         self.check_if_can_modify()
         self._storage_type = StorageType.MEMORY
@@ -516,6 +527,11 @@ def set_event_storage(self, event_storage: EventStorage) -> 'Builder':
         self._event_storage = event_storage
         return self
 
+    def set_verification_service(self, verification_service: VerificationService) -> 'Builder':
+        self.check_if_can_modify()
+        self._verification_service = verification_service
+        return self
+
     def set_reactor(self, reactor: Reactor) -> 'Builder':
         self.check_if_can_modify()
         self._reactor = reactor

hathor/builder/cli_builder.py

@@ -35,6 +35,7 @@
 from hathor.pubsub import PubSubManager
 from hathor.stratum import StratumFactory
 from hathor.util import Random, Reactor
+from hathor.verification.verification_service import VerificationService
 from hathor.wallet import BaseWallet, HDWallet, Wallet
 
 logger = get_logger()
@@ -202,6 +203,8 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             not_support_features=self._args.signal_not_support
         )
 
+        verification_service = VerificationService()
+
         p2p_manager = ConnectionsManager(
             reactor,
             network=network,
@@ -231,7 +234,8 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             full_verification=full_verification,
             enable_event_queue=self._args.x_enable_event_queue,
             feature_service=self.feature_service,
-            bit_signaling_service=bit_signaling_service
+            bit_signaling_service=bit_signaling_service,
+            verification_service=verification_service,
         )
 
         p2p_manager.set_manager(self.manager)

hathor/manager.py

@@ -57,6 +57,7 @@
 from hathor.transaction.storage.tx_allow_scope import TxAllowScope
 from hathor.types import Address, VertexId
 from hathor.util import EnvironmentInfo, LogDuration, Random, Reactor, calculate_min_significant_weight, not_none
+from hathor.verification.verification_service import VerificationService
 from hathor.wallet import BaseWallet
 
 settings = HathorSettings()
@@ -102,6 +103,7 @@ def __init__(self,
                  event_manager: EventManager,
                  feature_service: FeatureService,
                  bit_signaling_service: BitSignalingService,
+                 verification_service: VerificationService,
                  network: str,
                  hostname: Optional[str] = None,
                  wallet: Optional[BaseWallet] = None,
@@ -177,6 +179,7 @@ def __init__(self,
 
         self._feature_service = feature_service
         self._bit_signaling_service = bit_signaling_service
+        self.verification_service = verification_service
 
         self.consensus_algorithm = consensus_algorithm
 
@@ -453,7 +456,10 @@ def _initialize_components_full_verification(self) -> None:
                     tx.calculate_min_height()
                     if tx.is_genesis:
                         assert tx.validate_checkpoint(self.checkpoints)
-                    assert tx.validate_full(skip_block_weight_verification=skip_block_weight_verification)
+                    assert self.verification_service.validate_full(
+                        tx,
+                        skip_block_weight_verification=skip_block_weight_verification
+                    )
                     self.tx_storage.add_to_indexes(tx)
                     with self.tx_storage.allow_only_valid_context():
                         self.consensus_algorithm.update(tx)
@@ -464,7 +470,10 @@ def _initialize_components_full_verification(self) -> None:
                         self.sync_v2_step_validations([tx], quiet=True)
                     self.tx_storage.save_transaction(tx, only_metadata=True)
                 else:
-                    assert tx.validate_basic(skip_block_weight_verification=skip_block_weight_verification)
+                    assert self.verification_service.validate_basic(
+                        tx,
+                        skip_block_weight_verification=skip_block_weight_verification
+                    )
                     self.tx_storage.save_transaction(tx, only_metadata=True)
             except (InvalidNewTransaction, TxValidationError):
                 self.log.error('unexpected error when initializing', tx=tx, exc_info=True)
@@ -919,7 +928,7 @@ def push_tx(self, tx: Transaction, allow_non_standard_script: bool = False,
             raise NonStandardTxError('Transaction is non standard.')
 
         # Validate tx.
-        success, message = tx.validate_tx_error()
+        success, message = self.verification_service.validate_vertex_error(tx)
         if not success:
             raise InvalidNewTransaction(message)
 
@@ -992,7 +1001,7 @@ def on_new_tx(self, tx: BaseTransaction, *, conn: Optional[HathorProtocol] = Non
 
         if not metadata.validation.is_fully_connected():
             try:
-                tx.validate_full(reject_locked_reward=reject_locked_reward)
+                self.verification_service.validate_full(tx, reject_locked_reward=reject_locked_reward)
             except HathorError as e:
                 if not fails_silently:
                     raise InvalidNewTransaction('full validation failed') from e
@@ -1014,7 +1023,11 @@ def on_new_tx(self, tx: BaseTransaction, *, conn: Optional[HathorProtocol] = Non
             self.log.warn('on_new_tx(): consensus update failed', tx=tx.hash_hex, exc_info=True)
             return False
 
-        assert tx.validate_full(skip_block_weight_verification=True, reject_locked_reward=reject_locked_reward)
+        assert self.verification_service.validate_full(
+            tx,
+            skip_block_weight_verification=True,
+            reject_locked_reward=reject_locked_reward
+        )
         self.tx_storage.indexes.update(tx)
         if self.tx_storage.indexes.mempool_tips:
             self.tx_storage.indexes.mempool_tips.update(tx)  # XXX: move to indexes.update
@@ -1068,7 +1081,7 @@ def sync_v2_step_validations(self, txs: Iterable[BaseTransaction], *, quiet: boo
                     try:
                         # XXX: `reject_locked_reward` might not apply, partial validation is only used on sync-v2
                         # TODO: deal with `reject_locked_reward` on sync-v2
-                        assert tx.validate_full(reject_locked_reward=False)
+                        assert self.verification_service.validate_full(tx, reject_locked_reward=False)
                     except (AssertionError, HathorError):
                         # TODO
                         raise

hathor/p2p/sync_v2/agent.py

@@ -1154,7 +1154,7 @@ def on_new_tx(self, tx: BaseTransaction, *, quiet: bool = False, propagate_to_pe
                 if isinstance(tx, Block) and not tx.has_basic_block_parent():
                     self.log.warn('on_new_tx(): block parent needs to be at least basic-valid', tx=tx.hash_hex)
                     return False
-                if not tx.validate_basic():
+                if not self.manager.verification_service.validate_basic(tx):
                     self.log.warn('on_new_tx(): basic validation failed', tx=tx.hash_hex)
                     return False
 

hathor/transaction/base_transaction.py

@@ -39,7 +39,6 @@
     TimestampError,
     TooManyOutputs,
     TooManySigOps,
-    TxValidationError,
     WeightError,
 )
 from hathor.transaction.transaction_metadata import TransactionMetadata
@@ -514,42 +513,6 @@ def validate_checkpoint(self, checkpoints: list[Checkpoint]) -> bool:
         self.set_validation(ValidationState.CHECKPOINT)
         return True
 
-    def validate_basic(self, skip_block_weight_verification: bool = False) -> bool:
-        """ Run basic validations (all that are possible without dependencies) and update the validation state.
-
-        If no exception is raised, the ValidationState will end up as `BASIC` and return `True`.
-        """
-        self.verify_basic(skip_block_weight_verification=skip_block_weight_verification)
-        self.set_validation(ValidationState.BASIC)
-        return True
-
-    def validate_full(self, skip_block_weight_verification: bool = False, sync_checkpoints: bool = False,
-                      reject_locked_reward: bool = True) -> bool:
-        """ Run full validations (these need access to all dependencies) and update the validation state.
-
-        If no exception is raised, the ValidationState will end up as `FULL` or `CHECKPOINT_FULL` and return `True`.
-        """
-        from hathor.transaction.transaction_metadata import ValidationState
-
-        meta = self.get_metadata()
-
-        # skip full validation when it is a checkpoint
-        if meta.validation.is_checkpoint():
-            self.set_validation(ValidationState.CHECKPOINT_FULL)
-            return True
-
-        # XXX: in some cases it might be possible that this transaction is verified by a checkpoint but we went
-        #      directly into trying a full validation so we should check it here to make sure the validation states
-        #      ends up being CHECKPOINT_FULL instead of FULL
-        if not meta.validation.is_at_least_basic():
-            # run basic validation if we haven't already
-            self.verify_basic(skip_block_weight_verification=skip_block_weight_verification)
-
-        self.verify(reject_locked_reward=reject_locked_reward)
-        validation = ValidationState.CHECKPOINT_FULL if sync_checkpoints else ValidationState.FULL
-        self.set_validation(validation)
-        return True
-
     def _mark_partially_validated(self) -> None:
         """ This function is used to add the partially-validated mark from the voided-by metadata.
 
@@ -577,20 +540,6 @@ def verify_checkpoint(self, checkpoints: list[Checkpoint]) -> None:
         To be implemented by tx/block, used by `self.validate_checkpoint`. Should not modify the validation state."""
         raise NotImplementedError
 
-    @abstractmethod
-    def verify_basic(self, skip_block_weight_verification: bool = False) -> None:
-        """Basic verifications (the ones without access to dependencies: parents+inputs). Raises on error.
-
-        To be implemented by tx/block, used by `self.validate_basic`. Should not modify the validation state."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def verify(self, reject_locked_reward: bool = True) -> None:
-        """Run all verifications. Raises on error.
-
-        To be implemented by tx/block, used by `self.validate_full`. Should not modify the validation state."""
-        raise NotImplementedError
-
     def verify_parents(self) -> None:
         """All parents must exist and their timestamps must be smaller than ours.
 
@@ -1102,21 +1051,6 @@ def serialize_output(tx: BaseTransaction, tx_out: TxOutput) -> dict[str, Any]:
 
         return ret
 
-    def validate_tx_error(self) -> tuple[bool, str]:
-        """ Verify if tx is valid and return success and possible error message
-
-            :return: Success if tx is valid and possible error message, if not
-            :rtype: tuple[bool, str]
-        """
-        success = True
-        message = ''
-        try:
-            self.verify()
-        except TxValidationError as e:
-            success = False
-            message = str(e)
-        return success, message
-
     def clone(self) -> 'BaseTransaction':
         """Return exact copy without sharing memory, including metadata if loaded.
 

hathor/transaction/block.py

@@ -321,12 +321,6 @@ def has_basic_block_parent(self) -> bool:
             return False
         return metadata.validation.is_at_least_basic()
 
-    def verify_basic(self, skip_block_weight_verification: bool = False) -> None:
-        """Partially run validations, the ones that need parents/inputs are skipped."""
-        if not skip_block_weight_verification:
-            self.verify_weight()
-        self.verify_reward()
-
     def verify_checkpoint(self, checkpoints: list[Checkpoint]) -> None:
         assert self.hash is not None
         assert self.storage is not None
@@ -396,27 +390,6 @@ def get_base_hash(self) -> bytes:
         from hathor.merged_mining.bitcoin import sha256d_hash
         return sha256d_hash(self.get_header_without_nonce())
 
-    @cpu.profiler(key=lambda self: 'block-verify!{}'.format(self.hash.hex()))
-    def verify(self, reject_locked_reward: bool = True) -> None:
-        """
-            (1) confirms at least two pending transactions and references last block
-            (2) solves the pow with the correct weight (done in HathorManager)
-            (3) creates the correct amount of tokens in the output (done in HathorManager)
-            (4) all parents must exist and have timestamp smaller than ours
-            (5) data field must contain at most BLOCK_DATA_MAX_SIZE bytes
-        """
-        # TODO Should we validate a limit of outputs?
-        if self.is_genesis:
-            # TODO do genesis validation
-            return
-
-        self.verify_without_storage()
-
-        # (1) and (4)
-        self.verify_parents()
-
-        self.verify_height()
-
     def get_height(self) -> int:
         """Returns the block's height."""
         meta = self.get_metadata()

hathor/transaction/token_creation_tx.py

@@ -220,14 +220,6 @@ def to_json_extended(self) -> dict[str, Any]:
         json['tokens'] = []
         return json
 
-    def verify(self, reject_locked_reward: bool = True) -> None:
-        """ Run all validations as regular transactions plus validation on token info.
-
-        We also overload verify_sum to make some different checks
-        """
-        super().verify(reject_locked_reward=reject_locked_reward)
-        self.verify_token_info()
-
     def verify_sum(self) -> None:
         """ Besides all checks made on regular transactions, a few extra ones are made:
         - only HTR tokens on the inputs;

hathor/transaction/transaction.py

@@ -284,15 +284,6 @@ def to_json(self, decode_script: bool = False, include_metadata: bool = False) -
         json['tokens'] = [h.hex() for h in self.tokens]
         return json
 
-    def verify_basic(self, skip_block_weight_verification: bool = False) -> None:
-        """Partially run validations, the ones that need parents/inputs are skipped."""
-        if self.is_genesis:
-            # TODO do genesis validation?
-            return
-        self.verify_parents_basic()
-        self.verify_weight()
-        self.verify_without_storage()
-
     def verify_checkpoint(self, checkpoints: list[Checkpoint]) -> None:
         assert self.storage is not None
         if self.is_genesis:
@@ -328,30 +319,6 @@ def verify_weight(self) -> None:
             raise WeightError(f'Invalid new tx {self.hash_hex}: weight ({self.weight}) is '
                               f'greater than the maximum allowed ({max_tx_weight})')
 
-    @cpu.profiler(key=lambda self: 'tx-verify!{}'.format(self.hash.hex()))
-    def verify(self, reject_locked_reward: bool = True) -> None:
-        """ Common verification for all transactions:
-           (i) number of inputs is at most 256
-          (ii) number of outputs is at most 256
-         (iii) confirms at least two pending transactions
-          (iv) solves the pow (we verify weight is correct in HathorManager)
-           (v) validates signature of inputs
-          (vi) validates public key and output (of the inputs) addresses
-         (vii) validate that both parents are valid
-        (viii) validate input's timestamps
-          (ix) validate inputs and outputs sum
-        """
-        if self.is_genesis:
-            # TODO do genesis validation
-            return
-        self.verify_without_storage()
-        self.verify_sigops_input()
-        self.verify_inputs()  # need to run verify_inputs first to check if all inputs exist
-        self.verify_parents()
-        self.verify_sum()
-        if reject_locked_reward:
-            self.verify_reward_locked()
-
     def verify_unsigned_skip_pow(self) -> None:
         """ Same as .verify but skipping pow and signature verification."""
         self.verify_number_of_inputs()