diff --git a/hathor/cli/mining.py b/hathor/cli/mining.py index 8be4e348c..63ab8757c 100644 --- a/hathor/cli/mining.py +++ b/hathor/cli/mining.py @@ -138,11 +138,12 @@ def execute(args: Namespace) -> None: try: from hathor.daa import DifficultyAdjustmentAlgorithm - from hathor.verification.block_verifier import BlockVerifier + from hathor.verification.verification_service import VerificationService, VertexVerifiers settings = get_settings() daa = DifficultyAdjustmentAlgorithm(settings=settings) - verifier = BlockVerifier(settings=settings, daa=daa) - verifier.verify_without_storage(block) + verifiers = VertexVerifiers.create_defaults(settings=settings, daa=daa) + verification_service = VerificationService(verifiers=verifiers) + verification_service.verify_without_storage(block) except HathorError: print('[{}] ERROR: Block has not been pushed because it is not valid.'.format(datetime.datetime.now())) else: diff --git a/hathor/simulator/simulator.py b/hathor/simulator/simulator.py index f8ae953b7..45f5964e2 100644 --- a/hathor/simulator/simulator.py +++ b/hathor/simulator/simulator.py @@ -259,11 +259,7 @@ def _build_vertex_verifiers( """ return VertexVerifiers( block=SimulatorBlockVerifier(settings=settings, daa=daa, feature_service=feature_service), - merge_mined_block=SimulatorMergeMinedBlockVerifier( - settings=settings, - daa=daa, - feature_service=feature_service - ), + merge_mined_block=SimulatorMergeMinedBlockVerifier(), tx=SimulatorTransactionVerifier(settings=settings, daa=daa), token_creation_tx=SimulatorTokenCreationTransactionVerifier(settings=settings, daa=daa), ) diff --git a/hathor/verification/block_verifier.py b/hathor/verification/block_verifier.py index 7a2e91b84..99f4bf124 100644 --- a/hathor/verification/block_verifier.py +++ b/hathor/verification/block_verifier.py @@ -15,7 +15,6 @@ from hathor.conf.settings import HathorSettings from hathor.daa import DifficultyAdjustmentAlgorithm from hathor.feature_activation.feature_service import BlockIsMissingSignal, BlockIsSignaling, FeatureService -from hathor.profiler import get_cpu_profiler from hathor.transaction import BaseTransaction, Block from hathor.transaction.exceptions import ( BlockMustSignalError, @@ -28,8 +27,6 @@ ) from hathor.verification.vertex_verifier import VertexVerifier -cpu = get_cpu_profiler() - class BlockVerifier(VertexVerifier): __slots__ = ('_feature_service', ) @@ -44,45 +41,6 @@ def __init__( super().__init__(settings=settings, daa=daa) self._feature_service = feature_service - def verify_basic(self, block: Block, *, 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(block) - self.verify_reward(block) - - @cpu.profiler(key=lambda _, block: 'block-verify!{}'.format(block.hash.hex())) - def verify(self, block: Block) -> 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 - (6) whether this block must signal feature support - """ - # TODO Should we validate a limit of outputs? - if block.is_genesis: - # TODO do genesis validation - return - - self.verify_without_storage(block) - - # (1) and (4) - self.verify_parents(block) - - self.verify_height(block) - - self.verify_mandatory_signaling(block) - - def verify_without_storage(self, block: Block) -> None: - """ Run all verifications that do not need a storage. - """ - self.verify_pow(block) - self.verify_no_inputs(block) - self.verify_outputs(block) - self.verify_data(block) - self.verify_sigops_output(block) - def verify_height(self, block: Block) -> None: """Validate that the block height is enough to confirm all transactions being confirmed.""" meta = block.get_metadata() diff --git a/hathor/verification/merge_mined_block_verifier.py b/hathor/verification/merge_mined_block_verifier.py index 2090c9119..9314fbb2a 100644 --- a/hathor/verification/merge_mined_block_verifier.py +++ b/hathor/verification/merge_mined_block_verifier.py @@ -12,18 +12,12 @@ # See the License for the specific language governing permissions and # limitations under the License. -from hathor.transaction import Block, MergeMinedBlock -from hathor.verification.block_verifier import BlockVerifier +from hathor.transaction import MergeMinedBlock -class MergeMinedBlockVerifier(BlockVerifier): +class MergeMinedBlockVerifier: __slots__ = () - def verify_without_storage(self, block: Block) -> None: - assert isinstance(block, MergeMinedBlock) - self.verify_aux_pow(block) - super().verify_without_storage(block) - def verify_aux_pow(self, block: MergeMinedBlock) -> None: """ Verify auxiliary proof-of-work (for merged mining). """ diff --git a/hathor/verification/verification_service.py b/hathor/verification/verification_service.py index 3248d6516..5846c8865 100644 --- a/hathor/verification/verification_service.py +++ b/hathor/verification/verification_service.py @@ -19,6 +19,7 @@ from hathor.conf.settings import HathorSettings from hathor.daa import DifficultyAdjustmentAlgorithm from hathor.feature_activation.feature_service import FeatureService +from hathor.profiler import get_cpu_profiler from hathor.transaction import BaseTransaction, Block, MergeMinedBlock, Transaction, TxVersion from hathor.transaction.token_creation_tx import TokenCreationTransaction from hathor.transaction.validation_state import ValidationState @@ -27,6 +28,8 @@ from hathor.verification.token_creation_transaction_verifier import TokenCreationTransactionVerifier from hathor.verification.transaction_verifier import TransactionVerifier +cpu = get_cpu_profiler() + class VertexVerifiers(NamedTuple): """A group of verifier instances, one for each vertex type.""" @@ -49,7 +52,7 @@ def create_defaults( """ return VertexVerifiers( block=BlockVerifier(settings=settings, daa=daa, feature_service=feature_service), - merge_mined_block=MergeMinedBlockVerifier(settings=settings, daa=daa, feature_service=feature_service), + merge_mined_block=MergeMinedBlockVerifier(), tx=TransactionVerifier(settings=settings, daa=daa), token_creation_tx=TokenCreationTransactionVerifier(settings=settings, daa=daa), ) @@ -116,16 +119,10 @@ def verify_basic(self, vertex: BaseTransaction, *, skip_block_weight_verificatio match vertex.version: case TxVersion.REGULAR_BLOCK: assert type(vertex) is Block - self.verifiers.block.verify_basic( - vertex, - skip_block_weight_verification=skip_block_weight_verification - ) + self._verify_basic_block(vertex, skip_weight_verification=skip_block_weight_verification) case TxVersion.MERGE_MINED_BLOCK: assert type(vertex) is MergeMinedBlock - self.verifiers.merge_mined_block.verify_basic( - vertex, - skip_block_weight_verification=skip_block_weight_verification - ) + self._verify_basic_merge_mined_block(vertex, skip_weight_verification=skip_block_weight_verification) case TxVersion.REGULAR_TRANSACTION: assert type(vertex) is Transaction self.verifiers.tx.verify_basic(vertex) @@ -135,6 +132,15 @@ def verify_basic(self, vertex: BaseTransaction, *, skip_block_weight_verificatio case _: assert_never(vertex.version) + def _verify_basic_block(self, block: Block, *, skip_weight_verification: bool) -> None: + """Partially run validations, the ones that need parents/inputs are skipped.""" + if not skip_weight_verification: + self.verifiers.block.verify_weight(block) + self.verifiers.block.verify_reward(block) + + def _verify_basic_merge_mined_block(self, block: MergeMinedBlock, *, skip_weight_verification: bool) -> None: + self._verify_basic_block(block, skip_weight_verification=skip_weight_verification) + def verify(self, vertex: BaseTransaction, *, reject_locked_reward: bool = True) -> None: """Run all verifications. Raises on error. @@ -143,10 +149,10 @@ def verify(self, vertex: BaseTransaction, *, reject_locked_reward: bool = True) match vertex.version: case TxVersion.REGULAR_BLOCK: assert type(vertex) is Block - self.verifiers.block.verify(vertex) + self._verify_block(vertex) case TxVersion.MERGE_MINED_BLOCK: assert type(vertex) is MergeMinedBlock - self.verifiers.merge_mined_block.verify(vertex) + self._verify_merge_mined_block(vertex) case TxVersion.REGULAR_TRANSACTION: assert type(vertex) is Transaction self.verifiers.tx.verify(vertex, reject_locked_reward=reject_locked_reward) @@ -156,15 +162,42 @@ def verify(self, vertex: BaseTransaction, *, reject_locked_reward: bool = True) case _: assert_never(vertex.version) + @cpu.profiler(key=lambda _, block: 'block-verify!{}'.format(block.hash.hex())) + def _verify_block(self, block: Block) -> 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 + (6) whether this block must signal feature support + """ + # TODO Should we validate a limit of outputs? + if block.is_genesis: + # TODO do genesis validation + return + + self.verify_without_storage(block) + + # (1) and (4) + self.verifiers.block.verify_parents(block) + + self.verifiers.block.verify_height(block) + + self.verifiers.block.verify_mandatory_signaling(block) + + def _verify_merge_mined_block(self, block: MergeMinedBlock) -> None: + self._verify_block(block) + def verify_without_storage(self, vertex: BaseTransaction) -> None: # We assert with type() instead of isinstance() because each subclass has a specific branch. match vertex.version: case TxVersion.REGULAR_BLOCK: assert type(vertex) is Block - self.verifiers.block.verify_without_storage(vertex) + self._verify_without_storage_block(vertex) case TxVersion.MERGE_MINED_BLOCK: assert type(vertex) is MergeMinedBlock - self.verifiers.merge_mined_block.verify_without_storage(vertex) + self._verify_without_storage_merge_mined_block(vertex) case TxVersion.REGULAR_TRANSACTION: assert type(vertex) is Transaction self.verifiers.tx.verify_without_storage(vertex) @@ -173,3 +206,16 @@ def verify_without_storage(self, vertex: BaseTransaction) -> None: self.verifiers.token_creation_tx.verify_without_storage(vertex) case _: assert_never(vertex.version) + + def _verify_without_storage_block(self, block: Block) -> None: + """ Run all verifications that do not need a storage. + """ + self.verifiers.block.verify_pow(block) + self.verifiers.block.verify_no_inputs(block) + self.verifiers.block.verify_outputs(block) + self.verifiers.block.verify_data(block) + self.verifiers.block.verify_sigops_output(block) + + def _verify_without_storage_merge_mined_block(self, block: MergeMinedBlock) -> None: + self.verifiers.merge_mined_block.verify_aux_pow(block) + self._verify_without_storage_block(block) diff --git a/tests/tx/test_verification.py b/tests/tx/test_verification.py index 864a0e6a2..a7098adcb 100644 --- a/tests/tx/test_verification.py +++ b/tests/tx/test_verification.py @@ -137,7 +137,7 @@ def test_block_verify_without_storage(self) -> None: patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), patch.object(BlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), ): - self.verifiers.block.verify_without_storage(block) + self.manager.verification_service.verify_without_storage(block) # Block methods verify_pow_wrapped.assert_called_once() @@ -270,12 +270,12 @@ def test_block_validate_full(self) -> None: def test_merge_mined_block_verify_basic(self) -> None: block = self._get_valid_merge_mined_block() - verify_weight_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_weight) - verify_reward_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_reward) + verify_weight_wrapped = Mock(wraps=self.verifiers.block.verify_weight) + verify_reward_wrapped = Mock(wraps=self.verifiers.block.verify_reward) with ( - patch.object(MergeMinedBlockVerifier, 'verify_weight', verify_weight_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_reward', verify_reward_wrapped), + patch.object(BlockVerifier, 'verify_weight', verify_weight_wrapped), + patch.object(BlockVerifier, 'verify_reward', verify_reward_wrapped), ): self.manager.verification_service.verify_basic(block) @@ -286,25 +286,25 @@ def test_merge_mined_block_verify_basic(self) -> None: def test_merge_mined_block_verify_without_storage(self) -> None: block = self._get_valid_merge_mined_block() - verify_pow_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_no_inputs) - verify_outputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_outputs) - verify_number_of_outputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_data) - verify_sigops_output_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_sigops_output) + verify_pow_wrapped = Mock(wraps=self.verifiers.block.verify_pow) + verify_no_inputs_wrapped = Mock(wraps=self.verifiers.block.verify_no_inputs) + verify_outputs_wrapped = Mock(wraps=self.verifiers.block.verify_outputs) + verify_number_of_outputs_wrapped = Mock(wraps=self.verifiers.block.verify_number_of_outputs) + verify_data_wrapped = Mock(wraps=self.verifiers.block.verify_data) + verify_sigops_output_wrapped = Mock(wraps=self.verifiers.block.verify_sigops_output) verify_aux_pow_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_aux_pow) with ( - patch.object(MergeMinedBlockVerifier, 'verify_pow', verify_pow_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_outputs', verify_outputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_data', verify_data_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), + patch.object(BlockVerifier, 'verify_pow', verify_pow_wrapped), + patch.object(BlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(BlockVerifier, 'verify_outputs', verify_outputs_wrapped), + patch.object(BlockVerifier, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), + patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), + patch.object(BlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), patch.object(MergeMinedBlockVerifier, 'verify_aux_pow', verify_aux_pow_wrapped), ): - self.verifiers.merge_mined_block.verify_without_storage(block) + self.manager.verification_service.verify_without_storage(block) # Block methods verify_pow_wrapped.assert_called_once() @@ -320,29 +320,29 @@ def test_merge_mined_block_verify_without_storage(self) -> None: def test_merge_mined_block_verify(self) -> None: block = self._get_valid_merge_mined_block() - verify_pow_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_no_inputs) - verify_outputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_outputs) - verify_number_of_outputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_data) - verify_sigops_output_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_sigops_output) - verify_parents_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_parents) - verify_height_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_height) - verify_mandatory_signaling_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_mandatory_signaling) + verify_pow_wrapped = Mock(wraps=self.verifiers.block.verify_pow) + verify_no_inputs_wrapped = Mock(wraps=self.verifiers.block.verify_no_inputs) + verify_outputs_wrapped = Mock(wraps=self.verifiers.block.verify_outputs) + verify_number_of_outputs_wrapped = Mock(wraps=self.verifiers.block.verify_number_of_outputs) + verify_data_wrapped = Mock(wraps=self.verifiers.block.verify_data) + verify_sigops_output_wrapped = Mock(wraps=self.verifiers.block.verify_sigops_output) + verify_parents_wrapped = Mock(wraps=self.verifiers.block.verify_parents) + verify_height_wrapped = Mock(wraps=self.verifiers.block.verify_height) + verify_mandatory_signaling_wrapped = Mock(wraps=self.verifiers.block.verify_mandatory_signaling) verify_aux_pow_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_aux_pow) with ( - patch.object(MergeMinedBlockVerifier, 'verify_pow', verify_pow_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_outputs', verify_outputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_data', verify_data_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_parents', verify_parents_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_height', verify_height_wrapped), + patch.object(BlockVerifier, 'verify_pow', verify_pow_wrapped), + patch.object(BlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(BlockVerifier, 'verify_outputs', verify_outputs_wrapped), + patch.object(BlockVerifier, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), + patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), + patch.object(BlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), + patch.object(BlockVerifier, 'verify_parents', verify_parents_wrapped), + patch.object(BlockVerifier, 'verify_height', verify_height_wrapped), + patch.object(BlockVerifier, 'verify_mandatory_signaling', verify_mandatory_signaling_wrapped), patch.object(MergeMinedBlockVerifier, 'verify_aux_pow', verify_aux_pow_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_mandatory_signaling', verify_mandatory_signaling_wrapped), ): self.manager.verification_service.verify(block) @@ -363,12 +363,12 @@ def test_merge_mined_block_verify(self) -> None: def test_merge_mined_block_validate_basic(self) -> None: block = self._get_valid_merge_mined_block() - verify_weight_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_weight) - verify_reward_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_reward) + verify_weight_wrapped = Mock(wraps=self.verifiers.block.verify_weight) + verify_reward_wrapped = Mock(wraps=self.verifiers.block.verify_reward) with ( - patch.object(MergeMinedBlockVerifier, 'verify_weight', verify_weight_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_reward', verify_reward_wrapped), + patch.object(BlockVerifier, 'verify_weight', verify_weight_wrapped), + patch.object(BlockVerifier, 'verify_reward', verify_reward_wrapped), ): self.manager.verification_service.validate_basic(block) @@ -403,33 +403,33 @@ def test_merge_mined_block_validate_basic(self) -> None: def test_merge_mined_block_validate_full(self) -> None: block = self._get_valid_merge_mined_block() - verify_pow_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_no_inputs) - verify_outputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_outputs) - verify_number_of_outputs_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_data) - verify_sigops_output_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_sigops_output) - verify_parents_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_parents) - verify_height_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_height) - verify_weight_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_weight) - verify_reward_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_reward) - verify_mandatory_signaling_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_mandatory_signaling) + verify_pow_wrapped = Mock(wraps=self.verifiers.block.verify_pow) + verify_no_inputs_wrapped = Mock(wraps=self.verifiers.block.verify_no_inputs) + verify_outputs_wrapped = Mock(wraps=self.verifiers.block.verify_outputs) + verify_number_of_outputs_wrapped = Mock(wraps=self.verifiers.block.verify_number_of_outputs) + verify_data_wrapped = Mock(wraps=self.verifiers.block.verify_data) + verify_sigops_output_wrapped = Mock(wraps=self.verifiers.block.verify_sigops_output) + verify_parents_wrapped = Mock(wraps=self.verifiers.block.verify_parents) + verify_height_wrapped = Mock(wraps=self.verifiers.block.verify_height) + verify_weight_wrapped = Mock(wraps=self.verifiers.block.verify_weight) + verify_reward_wrapped = Mock(wraps=self.verifiers.block.verify_reward) + verify_mandatory_signaling_wrapped = Mock(wraps=self.verifiers.block.verify_mandatory_signaling) verify_aux_pow_wrapped = Mock(wraps=self.verifiers.merge_mined_block.verify_aux_pow) with ( - patch.object(MergeMinedBlockVerifier, 'verify_pow', verify_pow_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_outputs', verify_outputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_data', verify_data_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_parents', verify_parents_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_height', verify_height_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_weight', verify_weight_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_reward', verify_reward_wrapped), + patch.object(BlockVerifier, 'verify_pow', verify_pow_wrapped), + patch.object(BlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(BlockVerifier, 'verify_outputs', verify_outputs_wrapped), + patch.object(BlockVerifier, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), + patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), + patch.object(BlockVerifier, 'verify_sigops_output', verify_sigops_output_wrapped), + patch.object(BlockVerifier, 'verify_parents', verify_parents_wrapped), + patch.object(BlockVerifier, 'verify_height', verify_height_wrapped), + patch.object(BlockVerifier, 'verify_weight', verify_weight_wrapped), + patch.object(BlockVerifier, 'verify_reward', verify_reward_wrapped), + patch.object(BlockVerifier, 'verify_mandatory_signaling', verify_mandatory_signaling_wrapped), patch.object(MergeMinedBlockVerifier, 'verify_aux_pow', verify_aux_pow_wrapped), - patch.object(MergeMinedBlockVerifier, 'verify_mandatory_signaling', verify_mandatory_signaling_wrapped), ): self.manager.verification_service.validate_full(block)