IS-1208: Fix Balance bug

iconservice/icon_constant.py

@@ -134,10 +134,12 @@ class Revision(Enum):
     FIX_COIN_PART_BYTES_ENCODING = 9
     STRICT_SCORE_DECORATOR_CHECK = 9
 
-    LOCK_ADDRESS = 10
     FIX_UNSTAKE_BUG = 10
+    LOCK_ADDRESS = 10
+
+    FIX_BALANCE_BUG = 11
 
-    LATEST = 9
+    LATEST = 11
 
 
 RC_DB_VERSION_0 = 0

iconservice/icx/coin_part.py

@@ -49,7 +49,7 @@ def __str__(self) -> str:
 
 class CoinPartFlag(Flag):
     NONE = 0
-    HAS_UNSTAKE = 1
+    HAS_UNSTAKE = 1 # deprecated
 
 
 class CoinPart(BasePart):
@@ -130,7 +130,11 @@ def flags(self) -> 'CoinPartFlag':
         """
         return self._flags
 
-    def toggle_has_unstake(self, on: bool):
+    def toggle_has_unstake(self, on: bool, revision: int):
+        # deprecated flag
+        if revision >= Revision.FIX_BALANCE_BUG.value:
+            return
+
         new_flags = set_flag(self._flags, CoinPartFlag.HAS_UNSTAKE, on)
 
         if self._flags != new_flags:

iconservice/icx/icx_account.py

@@ -138,13 +138,13 @@ def normalize(self, revision: int):
         if self.coin_part is None or self.stake_part is None:
             return
 
-        balance: int = self.stake_part.normalize(self._current_block_height, revision)
-        if balance > 0:
+        expired_unstaked_balance: int = self.stake_part.normalize(self._current_block_height, revision)
+        if expired_unstaked_balance > 0:
             if self.coin_part is None:
                 raise InvalidParamsException('Failed to normalize: no coin part')
 
-            self.coin_part.toggle_has_unstake(False)
-            self.coin_part.deposit(balance)
+            self.coin_part.toggle_has_unstake(False, revision)
+            self.coin_part.deposit(expired_unstaked_balance)
 
     def set_stake(self, context: "IconScoreContext", value: int, unstake_lock_period: int):
         if self.coin_part is None or self.stake_part is None:
@@ -168,12 +168,12 @@ def set_stake(self, context: "IconScoreContext", value: int, unstake_lock_period
             self.stake_part.reset_unstake()
         else:
             unlock_block_height: int = self._current_block_height + unstake_lock_period
-            self.coin_part.toggle_has_unstake(True)
+            self.coin_part.toggle_has_unstake(True, context.revision)
             if context.revision >= Revision.MULTIPLE_UNSTAKE.value:
                 self.stake_part.set_unstakes_info(unlock_block_height,
                                                   -offset, context.unstake_slot_max)
             else:
-                self.stake_part.set_unstake(unlock_block_height,  -offset)
+                self.stake_part.set_unstake(unlock_block_height, -offset)
 
     def update_delegated_amount(self, offset: int):
         if self.delegation_part is None:

iconservice/icx/storage.py

@@ -27,7 +27,8 @@
 from ..base.ComponentBase import StorageBase
 from ..base.address import Address
 from ..base.block import Block, NULL_BLOCK
-from ..icon_constant import DEFAULT_BYTE_SIZE, DATA_BYTE_ORDER, ICX_LOG_TAG, ROLLBACK_LOG_TAG, IconScoreContextType
+from ..icon_constant import DEFAULT_BYTE_SIZE, DATA_BYTE_ORDER, ICX_LOG_TAG, ROLLBACK_LOG_TAG, IconScoreContextType, \
+    Revision
 from ..utils import bytes_to_hex
 
 if TYPE_CHECKING:
@@ -269,7 +270,26 @@ def get_account(self,
         if AccountPartFlag.COIN in part_flags:
             coin_part: 'CoinPart' = self._get_part(context, CoinPart, address)
 
-            if CoinPartFlag.HAS_UNSTAKE in coin_part.flags:
+            """
+            Ref IS-1208.
+            Mismatch has_unstake flag and actual unstake info below rev 10.
+            The reason that branch logic by revision is backward compatibility process on transfer ICX logic.
+
+            The below code is a logic that determines in advance whether it is possible or not before ICX transfer.
+
+            ### _process_transaction in icon_service_engine.py ###
+            # Checks the balance only on the invoke context(skip estimate context)
+            if context.type == IconScoreContextType.INVOKE:
+                tmp_context: 'IconScoreContext' = IconScoreContext(IconScoreContextType.QUERY)
+                tmp_context.block = self._get_last_block()
+                # Check if from account can charge a tx fee
+                self._icon_pre_validator.execute_to_check_out_of_balance(
+                    context if context.revision >= Revision.THREE.value else tmp_context,
+                    params,
+                    step_price=context.step_counter.step_price)
+            """
+            if context.revision >= Revision.FIX_BALANCE_BUG.value or \
+                    CoinPartFlag.HAS_UNSTAKE in coin_part.flags:
                 part_flags |= AccountPartFlag.STAKE
 
         if AccountPartFlag.STAKE in part_flags:

tests/integrate_test/iiss/decentralized/test_iiss_unstake.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2018 ICON Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""IconScoreEngine testcase
+"""
+from typing import TYPE_CHECKING, List
+
+from iconservice.icon_constant import Revision, ICX_IN_LOOP
+from tests.integrate_test.iiss.test_iiss_base import TestIISSBase
+
+if TYPE_CHECKING:
+    from iconservice.iconscore.icon_score_result import TransactionResult
+
+
+class TestIISSUnStake(TestIISSBase):
+    def test_unstake_balance_rev_10(self):
+        self._test_unstake_balance(
+            rev=Revision.FIX_UNSTAKE_BUG.value,
+            expected_expired_ustake_cnt=2,
+            expected_last_balance=0
+        )
+
+    def test_unstake_balance_rev_11(self):
+        self._test_unstake_balance(
+            rev=Revision.FIX_BALANCE_BUG.value,
+            expected_expired_ustake_cnt=3,
+            expected_last_balance=1 * ICX_IN_LOOP
+        )
+
+    def _test_unstake_balance(
+            self,
+            rev: int,
+            expected_expired_ustake_cnt: int,
+            expected_last_balance: int
+    ):
+        self.update_governance()
+
+        # set Revision REV_IISS
+        self.set_revision(Revision.IISS.value)
+
+        # gain 10 icx
+        balance: int = 10 * ICX_IN_LOOP
+        self.distribute_icx(
+            accounts=self._accounts[:1],
+            init_balance=balance
+        )
+
+        # set stake
+        target_stake: int = 8
+        stake: int = target_stake * ICX_IN_LOOP
+        tx_results: List['TransactionResult'] = self.set_stake(
+            from_=self._accounts[0],
+            value=stake
+        )
+        fee = tx_results[0].step_used * tx_results[0].step_price
+        expected_balance: int = balance - stake - fee
+        response: int = self.get_balance(self._accounts[0])
+        self.assertEqual(expected_balance, response)
+
+        self.set_revision(Revision.MULTIPLE_UNSTAKE.value)
+
+        for i in range(6):
+            self.set_stake(
+                from_=self._accounts[0],
+                value=stake - (i+1) * ICX_IN_LOOP
+            )
+
+        last_balance: int = self.get_balance(self._accounts[0])
+
+        actual_res: dict = self.get_stake(self._accounts[0])
+        first_remaining_blocks: int = 14
+        expected_res = {
+            "stake": stake - 1 * ICX_IN_LOOP * 6,
+            "unstakes": [
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 25, "remainingBlocks": first_remaining_blocks},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 26, "remainingBlocks": first_remaining_blocks+1},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 27, "remainingBlocks": first_remaining_blocks+2},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 28, "remainingBlocks": first_remaining_blocks+3},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 29, "remainingBlocks": first_remaining_blocks+4},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 30, "remainingBlocks": first_remaining_blocks+5},
+            ]
+        }
+        self.assertEqual(expected_res, actual_res)
+
+        self.set_revision(rev)
+
+        # 1st expired unstake
+        self.make_empty_blocks(first_remaining_blocks)
+
+        res: dict = self.get_stake(self._accounts[0])
+        expected_res = {
+            "stake": stake - 1 * ICX_IN_LOOP * 6,
+            "unstakes": [
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 26, "remainingBlocks": 0},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 27, "remainingBlocks": 1},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 28, "remainingBlocks": 2},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 29, "remainingBlocks": 3},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 30, "remainingBlocks": 4},
+            ]
+        }
+        self.assertEqual(res, expected_res)
+
+        tx_results = self.transfer_icx(from_=self._accounts[0], to_=self._accounts[1], value=0)
+
+        res: dict = self.get_stake(self._accounts[0])
+        expected_res = {
+            "stake": stake - 1 * ICX_IN_LOOP * 6,
+            "unstakes": [
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 27, "remainingBlocks": 0},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 28, "remainingBlocks": 1},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 29, "remainingBlocks": 2},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 30, "remainingBlocks": 3},
+            ]
+        }
+        self.assertEqual(res, expected_res)
+
+        estimate_fee = tx_results[0].step_used * tx_results[0].step_price
+
+        # 2nd expired unstake
+        self.make_empty_blocks(1)
+
+        res: dict = self.get_stake(self._accounts[0])
+        expected_res = {
+            "stake": stake - 1 * ICX_IN_LOOP * 6,
+            "unstakes": [
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 28, "remainingBlocks": 0},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 29, "remainingBlocks": 1},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 30, "remainingBlocks": 2},
+            ]
+        }
+        self.assertEqual(res, expected_res)
+
+        current_balance: int = self.get_balance(self._accounts[0])
+        expected_exipred_stake_balance: int = 1 * ICX_IN_LOOP * expected_expired_ustake_cnt
+        expected_balance: int = last_balance + expected_exipred_stake_balance - estimate_fee
+        self.assertEqual(current_balance, expected_balance)
+
+        self.transfer_icx(
+            from_=self._accounts[0],
+            to_=self._accounts[1],
+            value=expected_balance-estimate_fee,
+            disable_pre_validate=True,
+            step_limit=1 * 10 ** 5,
+            expected_status=True
+        )
+
+        res: dict = self.get_stake(self._accounts[0])
+        expected_res = {
+            "stake": stake - 1 * ICX_IN_LOOP * 6,
+            "unstakes": [
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 29, "remainingBlocks": 0},
+                {"unstake": 1 * ICX_IN_LOOP, "unstakeBlockHeight": 30, "remainingBlocks": 1},
+            ]
+        }
+        self.assertEqual(res, expected_res)
+
+        balance: int = self.get_balance(self._accounts[0])
+        self.assertEqual(balance, expected_last_balance)

tests/unit_test/icx/test_icx_account.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2019 ICON Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import copy
+from unittest.mock import PropertyMock
+
+import pytest
+
+from iconservice import Address
+from iconservice.base.block import Block
+from iconservice.icon_constant import Revision, IconScoreContextType
+from iconservice.iconscore.context.context import ContextContainer
+from iconservice.iconscore.icon_score_context import IconScoreContext
+from iconservice.icx.coin_part import CoinPart, CoinPartFlag, CoinPartType
+from iconservice.icx.icx_account import Account
+from iconservice.icx.stake_part import StakePart
+
+ADDRESS = Address.from_string(f"hx{'1234'*10}")
+UNSTAKE_LOCK_PERIOD = 20
+WITHDRAWAL_AMOUNT = 10
+
+
+@pytest.fixture(scope="function")
+def context():
+    ctx = IconScoreContext(IconScoreContextType.DIRECT)
+    block = Block(0, None, 0, None, 0)
+    ctx.block = block
+    ContextContainer._push_context(ctx)
+    yield ctx
+    ContextContainer._pop_context()
+
+
+class TestAccount:
+
+    @pytest.mark.parametrize("revision", [
+        revision.value for revision in Revision if revision.value >= Revision.MULTIPLE_UNSTAKE.value
+    ])
+    @pytest.mark.parametrize("flag", [CoinPartFlag.NONE, CoinPartFlag.HAS_UNSTAKE])
+    @pytest.mark.parametrize("unstakes_info, current_block_height, expected_balance", [
+        (None, 20, 100),
+        ([], 20, 100),
+        ([[10, 20]], 5, 100),
+        ([[10, 20]], 20, 100),
+        ([[10, 20]], 25, 110),
+        ([[10, 20], [10, 30]], 15, 100),
+        ([[10, 20], [10, 30]], 20, 100),
+        ([[10, 20], [10, 30]], 25, 110),
+        ([[10, 20], [10, 30]], 30, 110),
+        ([[10, 20], [10, 30]], 35, 120),
+    ])
+    def test_normalize(
+            self, context, mocker, revision, unstakes_info, current_block_height, flag, expected_balance):
+        unstakes_info = copy.deepcopy(unstakes_info)
+        mocker.patch.object(IconScoreContext, "revision", PropertyMock(return_value=revision))
+        stake, balance = 100, 100
+
+        coin_part = CoinPart(CoinPartType.GENERAL, flag, balance)
+        stake_part = StakePart(stake=stake, unstake=0, unstake_block_height=0, unstakes_info=unstakes_info)
+        account = Account(
+            ADDRESS, current_block_height, revision, coin_part=coin_part, stake_part=stake_part)
+
+        if unstakes_info is None:
+            remaining_unstakes = []
+        else:
+            remaining_unstakes = [
+                unstake_info for unstake_info in unstakes_info if unstake_info[1] >= current_block_height
+            ]
+
+        account.normalize(revision)
+
+        assert account.stake == stake
+        assert account.balance == expected_balance
+        assert account.unstakes_info == remaining_unstakes