diff --git a/hathor/transaction/block.py b/hathor/transaction/block.py index bef6f3368..fe014f0ab 100644 --- a/hathor/transaction/block.py +++ b/hathor/transaction/block.py @@ -18,21 +18,12 @@ from struct import pack from typing import TYPE_CHECKING, Any, Optional -from hathor import daa from hathor.checkpoint import Checkpoint from hathor.feature_activation.feature import Feature from hathor.feature_activation.model.feature_state import FeatureState from hathor.profiler import get_cpu_profiler from hathor.transaction import BaseTransaction, TxOutput, TxVersion -from hathor.transaction.exceptions import ( - BlockWithInputs, - BlockWithTokensError, - CheckpointError, - InvalidBlockReward, - RewardLocked, - TransactionDataError, - WeightError, -) +from hathor.transaction.exceptions import BlockWithTokensError, CheckpointError from hathor.transaction.util import VerboseCallback, int_to_bytes, unpack, unpack_len from hathor.util import not_none from hathor.utils.int import get_bit_list @@ -337,55 +328,12 @@ def verify_checkpoint(self, checkpoints: list[Checkpoint]) -> None: # TODO: check whether self is a parent of any checkpoint-valid block, this is left for a future PR pass - def verify_weight(self) -> None: - """Validate minimum block difficulty.""" - block_weight = daa.calculate_block_difficulty(self) - if self.weight < block_weight - self._settings.WEIGHT_TOL: - raise WeightError(f'Invalid new block {self.hash_hex}: weight ({self.weight}) is ' - f'smaller than the minimum weight ({block_weight})') - - def verify_height(self) -> None: - """Validate that the block height is enough to confirm all transactions being confirmed.""" - meta = self.get_metadata() - assert meta.height is not None - assert meta.min_height is not None - if meta.height < meta.min_height: - raise RewardLocked(f'Block needs {meta.min_height} height but has {meta.height}') - - def verify_reward(self) -> None: - """Validate reward amount.""" - parent_block = self.get_block_parent() - tokens_issued_per_block = daa.get_tokens_issued_per_block(parent_block.get_height() + 1) - if self.sum_outputs != tokens_issued_per_block: - raise InvalidBlockReward( - f'Invalid number of issued tokens tag=invalid_issued_tokens tx.hash={self.hash_hex} ' - f'issued={self.sum_outputs} allowed={tokens_issued_per_block}' - ) - - def verify_no_inputs(self) -> None: - inputs = getattr(self, 'inputs', None) - if inputs: - raise BlockWithInputs('number of inputs {}'.format(len(inputs))) - def verify_outputs(self) -> None: super().verify_outputs() for output in self.outputs: if output.get_token_index() > 0: raise BlockWithTokensError('in output: {}'.format(output.to_human_readable())) - def verify_data(self) -> None: - if len(self.data) > self._settings.BLOCK_DATA_MAX_SIZE: - raise TransactionDataError('block data has {} bytes'.format(len(self.data))) - - def verify_without_storage(self) -> None: - """ Run all verifications that do not need a storage. - """ - self.verify_pow() - self.verify_no_inputs() - self.verify_outputs() - self.verify_data() - self.verify_sigops_output() - def get_base_hash(self) -> bytes: from hathor.merged_mining.bitcoin import sha256d_hash return sha256d_hash(self.get_header_without_nonce()) diff --git a/hathor/transaction/merge_mined_block.py b/hathor/transaction/merge_mined_block.py index 121011a23..a6818ecde 100644 --- a/hathor/transaction/merge_mined_block.py +++ b/hathor/transaction/merge_mined_block.py @@ -74,13 +74,3 @@ def to_json(self, decode_script: bool = False, include_metadata: bool = False) - del json['nonce'] json['aux_pow'] = bytes(self.aux_pow).hex() if self.aux_pow else None return json - - def verify_without_storage(self) -> None: - self.verify_aux_pow() - super().verify_without_storage() - - def verify_aux_pow(self) -> None: - """ Verify auxiliary proof-of-work (for merged mining). - """ - assert self.aux_pow is not None - self.aux_pow.verify(self.get_base_hash()) diff --git a/hathor/verification/block_verifier.py b/hathor/verification/block_verifier.py index ae4c65c60..08781394d 100644 --- a/hathor/verification/block_verifier.py +++ b/hathor/verification/block_verifier.py @@ -12,8 +12,16 @@ # See the License for the specific language governing permissions and # limitations under the License. +from hathor import daa from hathor.profiler import get_cpu_profiler from hathor.transaction import BaseTransaction, Block +from hathor.transaction.exceptions import ( + BlockWithInputs, + InvalidBlockReward, + RewardLocked, + TransactionDataError, + WeightError, +) from hathor.verification.vertex_verifier import VertexVerifier cpu = get_cpu_profiler() @@ -52,25 +60,45 @@ def verify(self, block: Block) -> None: def verify_without_storage(self, block: Block) -> None: """ Run all verifications that do not need a storage. """ - block.verify_without_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.""" - block.verify_height() + meta = block.get_metadata() + assert meta.height is not None + assert meta.min_height is not None + if meta.height < meta.min_height: + raise RewardLocked(f'Block needs {meta.min_height} height but has {meta.height}') def verify_weight(self, block: Block) -> None: """Validate minimum block difficulty.""" - block.verify_weight() + min_block_weight = daa.calculate_block_difficulty(block) + if block.weight < min_block_weight - self._settings.WEIGHT_TOL: + raise WeightError(f'Invalid new block {block.hash_hex}: weight ({block.weight}) is ' + f'smaller than the minimum weight ({min_block_weight})') def verify_reward(self, block: Block) -> None: """Validate reward amount.""" - block.verify_reward() + parent_block = block.get_block_parent() + tokens_issued_per_block = daa.get_tokens_issued_per_block(parent_block.get_height() + 1) + if block.sum_outputs != tokens_issued_per_block: + raise InvalidBlockReward( + f'Invalid number of issued tokens tag=invalid_issued_tokens tx.hash={block.hash_hex} ' + f'issued={block.sum_outputs} allowed={tokens_issued_per_block}' + ) def verify_no_inputs(self, block: Block) -> None: - block.verify_no_inputs() + inputs = getattr(block, 'inputs', None) + if inputs: + raise BlockWithInputs('number of inputs {}'.format(len(inputs))) def verify_outputs(self, block: BaseTransaction) -> None: block.verify_outputs() def verify_data(self, block: Block) -> None: - block.verify_data() + if len(block.data) > self._settings.BLOCK_DATA_MAX_SIZE: + raise TransactionDataError('block data has {} bytes'.format(len(block.data))) diff --git a/hathor/verification/merge_mined_block_verifier.py b/hathor/verification/merge_mined_block_verifier.py index 508d850d7..2090c9119 100644 --- a/hathor/verification/merge_mined_block_verifier.py +++ b/hathor/verification/merge_mined_block_verifier.py @@ -12,14 +12,20 @@ # See the License for the specific language governing permissions and # limitations under the License. -from hathor.transaction import MergeMinedBlock +from hathor.transaction import Block, MergeMinedBlock from hathor.verification.block_verifier import BlockVerifier class MergeMinedBlockVerifier(BlockVerifier): __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). """ - block.verify_aux_pow() + assert block.aux_pow is not None + block.aux_pow.verify(block.get_base_hash()) diff --git a/tests/tx/test_verification.py b/tests/tx/test_verification.py index cdbcd6edd..be137dada 100644 --- a/tests/tx/test_verification.py +++ b/tests/tx/test_verification.py @@ -20,6 +20,8 @@ from hathor.transaction.scripts import P2PKH from hathor.transaction.token_creation_tx import TokenCreationTransaction from hathor.transaction.validation_state import ValidationState +from hathor.verification.block_verifier import BlockVerifier +from hathor.verification.merge_mined_block_verifier import MergeMinedBlockVerifier from tests import unittest from tests.utils import add_blocks_unlock_reward, create_tokens, get_genesis_key @@ -99,14 +101,15 @@ def _get_valid_token_creation_tx(self) -> TokenCreationTransaction: return create_tokens(self.manager, self.manager.wallet.get_unused_address()) def test_block_verify_basic(self) -> None: + verifier = self.manager.verification_service.verifiers.block block = self._get_valid_block() - verify_weight_wrapped = Mock(wraps=block.verify_weight) - verify_reward_wrapped = Mock(wraps=block.verify_reward) + verify_weight_wrapped = Mock(wraps=verifier.verify_weight) + verify_reward_wrapped = Mock(wraps=verifier.verify_reward) with ( - patch.object(Block, 'verify_weight', verify_weight_wrapped), - patch.object(Block, '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) @@ -115,24 +118,25 @@ def test_block_verify_basic(self) -> None: verify_reward_wrapped.assert_called_once() def test_block_verify_without_storage(self) -> None: + verifier = self.manager.verification_service.verifiers.block block = self._get_valid_block() verify_pow_wrapped = Mock(wraps=block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=block.verify_no_inputs) + verify_no_inputs_wrapped = Mock(wraps=verifier.verify_no_inputs) verify_outputs_wrapped = Mock(wraps=block.verify_outputs) verify_number_of_outputs_wrapped = Mock(wraps=block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=block.verify_data) + verify_data_wrapped = Mock(wraps=verifier.verify_data) verify_sigops_output_wrapped = Mock(wraps=block.verify_sigops_output) with ( patch.object(Block, 'verify_pow', verify_pow_wrapped), - patch.object(Block, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(BlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), patch.object(Block, 'verify_outputs', verify_outputs_wrapped), patch.object(Block, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(Block, 'verify_data', verify_data_wrapped), + patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), patch.object(Block, 'verify_sigops_output', verify_sigops_output_wrapped), ): - block.verify_without_storage() + verifier.verify_without_storage(block) # Block methods verify_pow_wrapped.assert_called_once() @@ -143,26 +147,27 @@ def test_block_verify_without_storage(self) -> None: verify_sigops_output_wrapped.assert_called_once() def test_block_verify(self) -> None: + verifier = self.manager.verification_service.verifiers.block block = self._get_valid_block() verify_pow_wrapped = Mock(wraps=block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=block.verify_no_inputs) + verify_no_inputs_wrapped = Mock(wraps=verifier.verify_no_inputs) verify_outputs_wrapped = Mock(wraps=block.verify_outputs) verify_number_of_outputs_wrapped = Mock(wraps=block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=block.verify_data) + verify_data_wrapped = Mock(wraps=verifier.verify_data) verify_sigops_output_wrapped = Mock(wraps=block.verify_sigops_output) verify_parents_wrapped = Mock(wraps=block.verify_parents) - verify_height_wrapped = Mock(wraps=block.verify_height) + verify_height_wrapped = Mock(wraps=verifier.verify_height) with ( patch.object(Block, 'verify_pow', verify_pow_wrapped), - patch.object(Block, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(BlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), patch.object(Block, 'verify_outputs', verify_outputs_wrapped), patch.object(Block, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(Block, 'verify_data', verify_data_wrapped), + patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), patch.object(Block, 'verify_sigops_output', verify_sigops_output_wrapped), patch.object(Block, 'verify_parents', verify_parents_wrapped), - patch.object(Block, 'verify_height', verify_height_wrapped), + patch.object(BlockVerifier, 'verify_height', verify_height_wrapped), ): self.manager.verification_service.verify(block) @@ -177,14 +182,15 @@ def test_block_verify(self) -> None: verify_height_wrapped.assert_called_once() def test_block_validate_basic(self) -> None: + verifier = self.manager.verification_service.verifiers.block block = self._get_valid_block() - verify_weight_wrapped = Mock(wraps=block.verify_weight) - verify_reward_wrapped = Mock(wraps=block.verify_reward) + verify_weight_wrapped = Mock(wraps=verifier.verify_weight) + verify_reward_wrapped = Mock(wraps=verifier.verify_reward) with ( - patch.object(Block, 'verify_weight', verify_weight_wrapped), - patch.object(Block, '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) @@ -193,30 +199,31 @@ def test_block_validate_basic(self) -> None: verify_reward_wrapped.assert_called_once() def test_block_validate_full(self) -> None: + verifier = self.manager.verification_service.verifiers.block block = self._get_valid_block() verify_pow_wrapped = Mock(wraps=block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=block.verify_no_inputs) + verify_no_inputs_wrapped = Mock(wraps=verifier.verify_no_inputs) verify_outputs_wrapped = Mock(wraps=block.verify_outputs) verify_number_of_outputs_wrapped = Mock(wraps=block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=block.verify_data) + verify_data_wrapped = Mock(wraps=verifier.verify_data) verify_sigops_output_wrapped = Mock(wraps=block.verify_sigops_output) verify_parents_wrapped = Mock(wraps=block.verify_parents) - verify_height_wrapped = Mock(wraps=block.verify_height) - verify_weight_wrapped = Mock(wraps=block.verify_weight) - verify_reward_wrapped = Mock(wraps=block.verify_reward) + verify_height_wrapped = Mock(wraps=verifier.verify_height) + verify_weight_wrapped = Mock(wraps=verifier.verify_weight) + verify_reward_wrapped = Mock(wraps=verifier.verify_reward) with ( patch.object(Block, 'verify_pow', verify_pow_wrapped), - patch.object(Block, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(BlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), patch.object(Block, 'verify_outputs', verify_outputs_wrapped), patch.object(Block, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(Block, 'verify_data', verify_data_wrapped), + patch.object(BlockVerifier, 'verify_data', verify_data_wrapped), patch.object(Block, 'verify_sigops_output', verify_sigops_output_wrapped), patch.object(Block, 'verify_parents', verify_parents_wrapped), - patch.object(Block, 'verify_height', verify_height_wrapped), - patch.object(Block, 'verify_weight', verify_weight_wrapped), - patch.object(Block, 'verify_reward', verify_reward_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), ): self.manager.verification_service.validate_full(block) @@ -233,14 +240,15 @@ def test_block_validate_full(self) -> None: verify_reward_wrapped.assert_called_once() def test_merge_mined_block_verify_basic(self) -> None: + verifier = self.manager.verification_service.verifiers.merge_mined_block block = self._get_valid_merge_mined_block() - verify_weight_wrapped = Mock(wraps=block.verify_weight) - verify_reward_wrapped = Mock(wraps=block.verify_reward) + verify_weight_wrapped = Mock(wraps=verifier.verify_weight) + verify_reward_wrapped = Mock(wraps=verifier.verify_reward) with ( - patch.object(MergeMinedBlock, 'verify_weight', verify_weight_wrapped), - patch.object(MergeMinedBlock, 'verify_reward', verify_reward_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_weight', verify_weight_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_reward', verify_reward_wrapped), ): self.manager.verification_service.verify_basic(block) @@ -249,27 +257,28 @@ def test_merge_mined_block_verify_basic(self) -> None: verify_reward_wrapped.assert_called_once() def test_merge_mined_block_verify_without_storage(self) -> None: + verifier = self.manager.verification_service.verifiers.merge_mined_block block = self._get_valid_merge_mined_block() verify_pow_wrapped = Mock(wraps=block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=block.verify_no_inputs) + verify_no_inputs_wrapped = Mock(wraps=verifier.verify_no_inputs) verify_outputs_wrapped = Mock(wraps=block.verify_outputs) verify_number_of_outputs_wrapped = Mock(wraps=block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=block.verify_data) + verify_data_wrapped = Mock(wraps=verifier.verify_data) verify_sigops_output_wrapped = Mock(wraps=block.verify_sigops_output) - verify_aux_pow_wrapped = Mock(wraps=block.verify_aux_pow) + verify_aux_pow_wrapped = Mock(wraps=verifier.verify_aux_pow) with ( patch.object(MergeMinedBlock, 'verify_pow', verify_pow_wrapped), - patch.object(MergeMinedBlock, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), patch.object(MergeMinedBlock, 'verify_outputs', verify_outputs_wrapped), patch.object(MergeMinedBlock, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(MergeMinedBlock, 'verify_data', verify_data_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_data', verify_data_wrapped), patch.object(MergeMinedBlock, 'verify_sigops_output', verify_sigops_output_wrapped), - patch.object(MergeMinedBlock, 'verify_aux_pow', verify_aux_pow_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_aux_pow', verify_aux_pow_wrapped), ): - block.verify_without_storage() + verifier.verify_without_storage(block) # Block methods verify_pow_wrapped.assert_called_once() @@ -283,29 +292,30 @@ def test_merge_mined_block_verify_without_storage(self) -> None: verify_pow_wrapped.assert_called_once() def test_merge_mined_block_verify(self) -> None: + verifier = self.manager.verification_service.verifiers.merge_mined_block block = self._get_valid_merge_mined_block() verify_pow_wrapped = Mock(wraps=block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=block.verify_no_inputs) + verify_no_inputs_wrapped = Mock(wraps=verifier.verify_no_inputs) verify_outputs_wrapped = Mock(wraps=block.verify_outputs) verify_number_of_outputs_wrapped = Mock(wraps=block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=block.verify_data) + verify_data_wrapped = Mock(wraps=verifier.verify_data) verify_sigops_output_wrapped = Mock(wraps=block.verify_sigops_output) verify_parents_wrapped = Mock(wraps=block.verify_parents) - verify_height_wrapped = Mock(wraps=block.verify_height) + verify_height_wrapped = Mock(wraps=verifier.verify_height) - verify_aux_pow_wrapped = Mock(wraps=block.verify_aux_pow) + verify_aux_pow_wrapped = Mock(wraps=verifier.verify_aux_pow) with ( patch.object(MergeMinedBlock, 'verify_pow', verify_pow_wrapped), - patch.object(MergeMinedBlock, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), patch.object(MergeMinedBlock, 'verify_outputs', verify_outputs_wrapped), patch.object(MergeMinedBlock, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(MergeMinedBlock, 'verify_data', verify_data_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_data', verify_data_wrapped), patch.object(MergeMinedBlock, 'verify_sigops_output', verify_sigops_output_wrapped), patch.object(MergeMinedBlock, 'verify_parents', verify_parents_wrapped), - patch.object(MergeMinedBlock, 'verify_height', verify_height_wrapped), - patch.object(MergeMinedBlock, 'verify_aux_pow', verify_aux_pow_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_height', verify_height_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_aux_pow', verify_aux_pow_wrapped), ): self.manager.verification_service.verify(block) @@ -323,14 +333,15 @@ def test_merge_mined_block_verify(self) -> None: verify_pow_wrapped.assert_called_once() def test_merge_mined_block_validate_basic(self) -> None: + verifier = self.manager.verification_service.verifiers.merge_mined_block block = self._get_valid_merge_mined_block() - verify_weight_wrapped = Mock(wraps=block.verify_weight) - verify_reward_wrapped = Mock(wraps=block.verify_reward) + verify_weight_wrapped = Mock(wraps=verifier.verify_weight) + verify_reward_wrapped = Mock(wraps=verifier.verify_reward) with ( - patch.object(MergeMinedBlock, 'verify_weight', verify_weight_wrapped), - patch.object(MergeMinedBlock, 'verify_reward', verify_reward_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_weight', verify_weight_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_reward', verify_reward_wrapped), ): self.manager.verification_service.validate_basic(block) @@ -339,33 +350,34 @@ def test_merge_mined_block_validate_basic(self) -> None: verify_reward_wrapped.assert_called_once() def test_merge_mined_block_validate_full(self) -> None: + verifier = self.manager.verification_service.verifiers.merge_mined_block block = self._get_valid_merge_mined_block() verify_pow_wrapped = Mock(wraps=block.verify_pow) - verify_no_inputs_wrapped = Mock(wraps=block.verify_no_inputs) + verify_no_inputs_wrapped = Mock(wraps=verifier.verify_no_inputs) verify_outputs_wrapped = Mock(wraps=block.verify_outputs) verify_number_of_outputs_wrapped = Mock(wraps=block.verify_number_of_outputs) - verify_data_wrapped = Mock(wraps=block.verify_data) + verify_data_wrapped = Mock(wraps=verifier.verify_data) verify_sigops_output_wrapped = Mock(wraps=block.verify_sigops_output) verify_parents_wrapped = Mock(wraps=block.verify_parents) - verify_height_wrapped = Mock(wraps=block.verify_height) - verify_weight_wrapped = Mock(wraps=block.verify_weight) - verify_reward_wrapped = Mock(wraps=block.verify_reward) + verify_height_wrapped = Mock(wraps=verifier.verify_height) + verify_weight_wrapped = Mock(wraps=verifier.verify_weight) + verify_reward_wrapped = Mock(wraps=verifier.verify_reward) - verify_aux_pow_wrapped = Mock(wraps=block.verify_aux_pow) + verify_aux_pow_wrapped = Mock(wraps=verifier.verify_aux_pow) with ( patch.object(MergeMinedBlock, 'verify_pow', verify_pow_wrapped), - patch.object(MergeMinedBlock, 'verify_no_inputs', verify_no_inputs_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_no_inputs', verify_no_inputs_wrapped), patch.object(MergeMinedBlock, 'verify_outputs', verify_outputs_wrapped), patch.object(MergeMinedBlock, 'verify_number_of_outputs', verify_number_of_outputs_wrapped), - patch.object(MergeMinedBlock, 'verify_data', verify_data_wrapped), + patch.object(MergeMinedBlockVerifier, 'verify_data', verify_data_wrapped), patch.object(MergeMinedBlock, 'verify_sigops_output', verify_sigops_output_wrapped), patch.object(MergeMinedBlock, 'verify_parents', verify_parents_wrapped), - patch.object(MergeMinedBlock, 'verify_height', verify_height_wrapped), - patch.object(MergeMinedBlock, 'verify_weight', verify_weight_wrapped), - patch.object(MergeMinedBlock, 'verify_reward', verify_reward_wrapped), - patch.object(MergeMinedBlock, 'verify_aux_pow', verify_aux_pow_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(MergeMinedBlockVerifier, 'verify_aux_pow', verify_aux_pow_wrapped), ): self.manager.verification_service.validate_full(block)