Merge pull request #489 from icon-project/hotfix/1.7.2

Hotfix/1.7.2

iconservice/__init__.py

@@ -31,8 +31,6 @@
     create_address_with_key, create_interface_score
 )
 
-from .iconscore import icxunit
-
 from .iconscore.icon_system_score_base import IconSystemScoreBase
 from .iconscore.system_score import InterfaceSystemScore
 from .__version__ import __version__

iconservice/__version__.py

@@ -1 +1 @@
-__version__ = '1.7.1'
+__version__ = '1.7.2'

iconservice/icon_service_engine.py

@@ -753,7 +753,7 @@ def _update_productivity(cls,
 
         for address, vote_state in validators:
             dirty_prep: Optional['PRep'] = context.get_prep(address, mutable=True)
-            assert isinstance(dirty_prep, PRep)
+            assert isinstance(dirty_prep, PRep), f"dirty_prep: {address}"
 
             is_validator: bool = vote_state != BlockVoteStatus.NONE.value
 
@@ -776,7 +776,7 @@ def _update_last_generate_block_height(cls,
             return
 
         dirty_prep: 'PRep' = context.get_prep(prev_block_generator, mutable=True)
-        assert isinstance(dirty_prep, PRep)
+        assert isinstance(dirty_prep, PRep), f"dirty_prep: {address}"
 
         dirty_prep.last_generate_block_height = context.block.height - 1
         context.put_dirty_prep(dirty_prep)

iconservice/iconscore/icon_score_base.py

@@ -20,7 +20,6 @@
 from inspect import isfunction, signature, Parameter
 from typing import TYPE_CHECKING, Callable, Any, List, Tuple, Mapping
 
-from . import icxunit
 from .context.context import ContextGetter, ContextContainer
 from .icon_score_base2 import InterfaceScore, revert, Block
 from .icon_score_constant import (
@@ -64,15 +63,13 @@
 INDEXED_ARGS_LIMIT = 3
 
 
-def interface(func=None, *, payable=False):
+def interface(func):
     """
     A decorator for the functions of InterfaceScore.
 
     If other SCORE has the function whose signature is the same as defined with @interface decorator,
     the function can be invoked via InterfaceScore class instance
     """
-    if func is None:
-        return partial(interface, payable=payable)
 
     cls_name, func_name = str(func.__qualname__).split('.')
     if not isfunction(func):
@@ -83,27 +80,6 @@ def interface(func=None, *, payable=False):
 
     set_score_flag_on(func, ScoreFlag.INTERFACE)
 
-    sig = signature(func)
-    params = sig.parameters
-
-    it = reversed(params.items())
-    if payable:
-        try:
-            var_name, var_type = next(it)
-            if var_type.annotation is not icxunit.Loop:
-                raise StopIteration
-
-            default_value = var_type.default
-            if not (default_value is Parameter.empty or
-                    isinstance(default_value, icxunit.Loop)):
-                raise IllegalFormatException(f"Default value should be icxunit.Loop: {str(func.__qualname__)}")
-        except StopIteration:
-            raise IllegalFormatException(f"Last argument should be icxunit.Loop: {str(func.__qualname__)}")
-
-    for _, var_type in it:
-        if var_type.annotation is icxunit.Loop:
-            raise IllegalFormatException(f"icxunit.Loop is not allowed: {str(func.__qualname__)}")
-
     @wraps(func)
     def __wrapper(calling_obj: "InterfaceScore", *args, **kwargs):
         if not isinstance(calling_obj, InterfaceScore):
@@ -114,25 +90,8 @@ def __wrapper(calling_obj: "InterfaceScore", *args, **kwargs):
         addr_to = calling_obj.addr_to
         addr_from: 'Address' = context.current_address
 
-        if payable:
-            unit: Optional['icxunit.Loop'] = kwargs.get(var_name)
-            if unit:
-                amount = int(unit)
-                del kwargs[var_name]
-            else:
-                if args:
-                    unit: 'icxunit.Loop' = args[-1]
-                    if isinstance(unit, icxunit.Loop):
-                        amount = int(unit)
-                        args = tuple(args[:-1])
-                    else:
-                        raise InvalidParamsException(f"{type(unit)} is not icxunit.Loop")
-                else:
-                    if default_value is Parameter.empty:
-                        raise InvalidParamsException(f"{var_name} is not found")
-                    amount = int(default_value)
-        else:
-            amount = 0
+        amount: int = getattr(calling_obj, "_InterfaceScore__get_icx")()
+        getattr(calling_obj, "_InterfaceScore__reset_icx")()
 
         if addr_to is None:
             raise InvalidInterfaceException('Cannot create an interface SCORE with a None address')

iconservice/iconscore/icon_score_base2.py

@@ -53,6 +53,7 @@ def __init__(self, addr_to: 'Address'):
         A Python init function. Invoked when the contract call create_interface_score()
         """
         self.__addr_to = addr_to
+        self.__icx = 0
 
     @property
     def addr_to(self) -> 'Address':
@@ -63,6 +64,19 @@ def addr_to(self) -> 'Address':
         """
         return self.__addr_to
 
+    def icx(self, value: int):
+        if not (isinstance(value, int) and value >= 0):
+            raise InvalidParamsException(f"Invalid icx: {value}")
+
+        self.__icx = value
+        return self
+
+    def __get_icx(self) -> int:
+        return self.__icx
+
+    def __reset_icx(self):
+        self.__icx = 0
+
 
 class Block(object):
     def __init__(self, block_height: int, timestamp: int) -> None:
@@ -377,4 +391,3 @@ def create_interface_score(addr_to: 'Address',
         if interface_cls is InterfaceScore:
             raise InvalidInstanceException(FORMAT_IS_NOT_DERIVED_OF_OBJECT.format(InterfaceScore.__name__))
         return interface_cls(addr_to)
-

iconservice/iconscore/icon_score_context.py

@@ -242,7 +242,8 @@ def _update_prep_address_converter(self, dirty_prep: 'PRep'):
                                                               prev_node=old_prep.node_address)
         elif dirty_prep.status != PRepStatus.ACTIVE:
             # unregisterPRep or disqualified by productivity penalty
-            self._prep_address_converter.delete_node_address(node=dirty_prep.node_address)
+            self._prep_address_converter.delete_node_address(node=dirty_prep.node_address,
+                                                             prep=dirty_prep.address)
 
     def _update_term(self, dirty_prep: 'PRep'):
         """Update term info with dirty_prep

iconservice/prep/penalty_imposer.py

@@ -54,11 +54,15 @@ def run(self,
 
         if self._check_block_validation_penalty(prep):
             Logger.info(f"PenaltyImposer statistics({PenaltyReason.BLOCK_VALIDATION}): "
+                        f"prep: {prep.address} "
+                        f"node_address: {prep.node_address} "
                         f"prep_total_blocks: {prep.total_blocks} "
                         f"prep_block_validation_proportion: {prep.block_validation_proportion}")
             reason = PenaltyReason.BLOCK_VALIDATION
         if self._check_low_productivity_penalty(prep):
             Logger.info(f"PenaltyImposer statistics({PenaltyReason.LOW_PRODUCTIVITY}): "
+                        f"prep: {prep.address} "
+                        f"node_address: {prep.node_address} "
                         f"prep_total_blocks: {prep.total_blocks} "
                         f"prep_unvalidated_sequence_blocks: {prep.unvalidated_sequence_blocks}")
             reason = PenaltyReason.LOW_PRODUCTIVITY

iconservice/prep/prep_address_converter.py

@@ -71,7 +71,11 @@ def add_node_address(self, node: 'Address', prep: 'Address'):
             raise InvalidParamsException(f"nodeAddress already in use: {node}")
         self._node_address_mapper[node] = prep
 
-    def delete_node_address(self, node: 'Address'):
+    def delete_node_address(self, node: 'Address', prep: 'Address'):
+        self._add_prev_node_address(node=node, prep=prep)
+        self._delete_node_address(node)
+
+    def _delete_node_address(self, node: 'Address'):
         if node in self._node_address_mapper:
             del self._node_address_mapper[node]
 
@@ -81,7 +85,7 @@ def _add_prev_node_address(self, node: 'Address', prep: 'Address'):
 
     def replace_node_address(self, node: 'Address', prep: 'Address', prev_node: 'Address'):
         self._add_prev_node_address(node=prev_node, prep=prep)
-        self.delete_node_address(node=prev_node)
+        self._delete_node_address(node=prev_node)
         self.add_node_address(node=node, prep=prep)
 
     def copy(self) -> 'PRepAddressConverter':
@@ -99,6 +103,7 @@ def validate_node_address(self,
 
     def get_prep_address_from_node_address(self,
                                            node_address: 'Address') -> 'Address':
-
-        return self._prev_node_address_mapper.get(node_address,
-                                                  self._node_address_mapper.get(node_address, node_address))
+        ret: 'Address' = self._node_address_mapper.get(node_address)
+        if ret is None:
+            ret = self._prev_node_address_mapper.get(node_address, node_address)
+        return ret

tests/integrate_test/iiss/decentralized/test_preps_divide_node_address.py

@@ -150,10 +150,10 @@ def test_prep_set_node_address_check_generator(self):
         prev_block_generator = self._accounts[0].address
         prev_block_votes = [(x.address, True) for x in self._accounts[1:PREP_MAIN_PREPS]]
         block, tx_results, _, _, next_preps = self.debug_make_and_req_block(tx_list=[],
-                                                                                   prev_block_generator=prev_block_generator,
-                                                                                   prev_block_validators=None,
-                                                                                   prev_block_votes=prev_block_votes,
-                                                                                   block=None)
+                                                                            prev_block_generator=prev_block_generator,
+                                                                            prev_block_validators=None,
+                                                                            prev_block_votes=prev_block_votes,
+                                                                            block=None)
         self.assertEqual(tx_results[0].status, True)
         self.assertEqual(next_preps, None)
 
@@ -169,10 +169,10 @@ def test_prep_set_node_address_check_generator(self):
 
         prev_block_votes = [(x.address, True) for x in self._accounts[1:PREP_MAIN_PREPS]]
         block, tx_results, _, _, next_preps = self.debug_make_and_req_block(tx_list=[tx],
-                                                                                   prev_block_generator=prev_block_generator,
-                                                                                   prev_block_validators=None,
-                                                                                   prev_block_votes=prev_block_votes,
-                                                                                   block=None)
+                                                                            prev_block_generator=prev_block_generator,
+                                                                            prev_block_validators=None,
+                                                                            prev_block_votes=prev_block_votes,
+                                                                            block=None)
         self.assertEqual(tx_results[0].status, True)
         self.assertEqual(next_preps["preps"][0]["id"], dummy_node2)
         self._write_precommit_state(block)
@@ -207,10 +207,10 @@ def test_prep_set_node_address_check_votes(self):
         prev_block_generator = self._accounts[0].address
         prev_block_votes = [(x.address, True) for x in self._accounts[1:PREP_MAIN_PREPS]]
         block, tx_results, _, _, next_preps = self.debug_make_and_req_block(tx_list=[],
-                                                                                   prev_block_generator=prev_block_generator,
-                                                                                   prev_block_validators=None,
-                                                                                   prev_block_votes=prev_block_votes,
-                                                                                   block=None)
+                                                                            prev_block_generator=prev_block_generator,
+                                                                            prev_block_validators=None,
+                                                                            prev_block_votes=prev_block_votes,
+                                                                            block=None)
         self.assertEqual(tx_results[0].status, True)
         self.assertEqual(next_preps, None)
 
@@ -226,10 +226,10 @@ def test_prep_set_node_address_check_votes(self):
 
         prev_block_votes = [(x.address, True) for x in self._accounts[1:PREP_MAIN_PREPS]]
         block, tx_results, _, _, next_preps = self.debug_make_and_req_block(tx_list=[tx],
-                                                                                   prev_block_generator=prev_block_generator,
-                                                                                   prev_block_validators=None,
-                                                                                   prev_block_votes=prev_block_votes,
-                                                                                   block=None)
+                                                                            prev_block_generator=prev_block_generator,
+                                                                            prev_block_validators=None,
+                                                                            prev_block_votes=prev_block_votes,
+                                                                            block=None)
         self.assertEqual(tx_results[0].status, True)
         self.assertEqual(next_preps["preps"][1]["id"], dummy_node2)
         self._write_precommit_state(block)
@@ -474,3 +474,107 @@ def test_scenario6(self):
         # After calling write_precommit_state()
         ret: Dict[str, Union[str, int, bytes, 'Address']] = self.get_prep(prep_a)
         assert ret["nodeAddress"] == prep_a.address
+
+    def test_change_node_prep1(self):
+        # 1 block
+        # PRepA a ---- z
+        # penalty PRepA (low productivity)
+
+        self.set_revision(Revision.DIVIDE_NODE_ADDRESS.value)
+
+        self.distribute_icx(accounts=self._accounts[:PREP_MAIN_PREPS],
+                            init_balance=1 * ICX_IN_LOOP)
+
+        # PRepA: 0
+        # PRepB: 1
+        prep_a: 'EOAAccount' = self._accounts[0]
+        node_address: 'Address' = create_address()
+
+        tx_list: list = [
+            self.create_set_prep_tx(
+                from_=prep_a,
+                set_data={
+                    "nodeAddress": str(node_address)
+                }
+            )
+        ]
+
+        self.process_confirm_block_tx(
+            tx_list,
+            prev_block_generator=None,
+            prev_block_validators=None
+        )
+
+        PREV_PENALTY_GRACE_PERIOD = IconScoreContext.engine.prep._penalty_imposer._penalty_grace_period
+        PREV_LOW_PRODUCTIVITY_PENALTY_THRESHOLD = \
+            IconScoreContext.engine.prep._penalty_imposer._low_productivity_penalty_threshold
+
+        PENALTY_GRACE_PERIOD = 0
+        # enable low productivity
+        LOW_PRODUCTIVITY_PENALTY_THRESHOLD = 1
+
+        IconScoreContext.engine.prep._penalty_imposer._penalty_grace_period = PENALTY_GRACE_PERIOD
+        IconScoreContext.engine.prep._penalty_imposer._low_productivity_penalty_threshold = \
+            LOW_PRODUCTIVITY_PENALTY_THRESHOLD
+
+        votes = [[node_address, False]] + \
+                [[account.address, True] for account in self._accounts[2:PREP_MAIN_PREPS]]
+        tx_results = self.make_blocks(to=self._block_height + 2,
+                                      prev_block_generator=self._accounts[1].address,
+                                      prev_block_votes=votes)
+
+        # assert Error!
+        with self.assertRaises(AssertionError) as e:
+            self.make_blocks(
+                to=self._block_height + 1,
+                prev_block_generator=self._accounts[1].address,
+                prev_block_votes=votes)
+
+        self.assertEqual(e.exception.args[0], f"dirty_prep: {node_address}")
+
+        IconScoreContext.engine.prep._penalty_imposer._penalty_grace_period = PREV_PENALTY_GRACE_PERIOD
+        IconScoreContext.engine.prep._penalty_imposer._low_productivity_penalty_threshold = \
+            PREV_LOW_PRODUCTIVITY_PENALTY_THRESHOLD
+
+    def test_change_node_prep2(self):
+        # 1 block
+        # PRepA a ---- z
+        # unreg PRepA
+
+        self.set_revision(Revision.DIVIDE_NODE_ADDRESS.value)
+
+        self.distribute_icx(accounts=self._accounts[:PREP_MAIN_PREPS],
+                            init_balance=1 * ICX_IN_LOOP)
+
+        # PRepA: 0
+        # PRepB: 1
+        prep_a: 'EOAAccount' = self._accounts[0]
+        node_address: 'Address' = create_address()
+
+        tx_list: list = [
+            self.create_set_prep_tx(
+                from_=prep_a,
+                set_data={
+                    "nodeAddress": str(node_address)
+                }
+            )
+        ]
+
+        self.process_confirm_block_tx(tx_list)
+
+        self.unregister_prep(prep_a)
+
+        votes = [[node_address, False]] + \
+                [[account.address, True] for account in self._accounts[2:PREP_MAIN_PREPS]]
+        tx_results = self.make_blocks(to=self._block_height + 1,
+                                      prev_block_generator=self._accounts[1].address,
+                                      prev_block_votes=votes)
+
+        # assert Error!
+        with self.assertRaises(AssertionError) as e:
+            self.make_blocks(
+                to=self._block_height + 1,
+                prev_block_generator=self._accounts[1].address,
+                prev_block_votes=votes)
+
+        self.assertEqual(e.exception.args[0], f"dirty_prep: {node_address}")

tests/integrate_test/samples/icx_method_chaining/callee_score/package.json

@@ -0,0 +1,5 @@
+{
+    "version": "0.0.1",
+    "main_module": "score",
+    "main_score": "Score"
+}