Asset range option

While writing tests, I encountered a problem with the number of vests changing over time. I've created a function that works similarly to python's built-in range() function. It works like this:

tt.Asset.Range(tt.Asset.Test(1), tt.Asset.Test(2))

use analogous to:

range(1, 2)

This allowed me to achieve my goal:

assert tt.Asset.Test(2) in tt.Asset.Range(tt.Asset.Test(1), tt.Asset.Test(3))

I also added the option of specifying the upper deviation percentage:

tt.Asset.Range(tt.Asset.Test(1), percentage_range=10) 

the above case should be understood as follows: from tt.Asset.Test(1) to tt.Asset.Test(1) + 10%

@mzebrak, @kmochocki

package/test_tools/__private/asset.py

@@ -4,13 +4,15 @@ from copy import deepcopy
 from decimal import Decimal
 from functools import total_ordering
 import operator
-from typing import Any, Final, NoReturn, Optional, Union
+from typing import Any, Final, NoReturn, Optional, TypeVar, Union
 
 import abstractcp as acp
 
 from test_tools.__private.exceptions import ParseError
 from test_tools.__private.utilities.decimal_converter import DecimalConverter
 
+AssetLimitT = TypeVar("AssetLimitT", bound="AssetBase")
+
 
 @total_ordering
 class AssetBase(acp.Abstract):
@@ -128,7 +130,7 @@ class AssetBase(acp.Abstract):
         except ParseError as exception:
             raise TypeError(f"Can't {error_detail} asset: `{self}` and `{other}`.") from exception
 
-        self.__assert_same_token(other, error_detail=error_detail)
+        self.assert_same_token(self, other, error_detail=error_detail)
         return other
 
     def __handle_asset_conversion(self, other: Any, error_detail: str) -> AssetBase:
@@ -137,8 +139,7 @@ class AssetBase(acp.Abstract):
         if isinstance(other, (str, dict)):
             other = Asset.from_(other, treat_dict_as_testnet_currencies=is_testnet)
 
-        if not isinstance(other, AssetBase):
-            raise TypeError(f"Can't {error_detail} objects of type `{type(other)}`.")
+        self.assert_is_asset(other, error_detail=error_detail)
         return other
 
     @classmethod
@@ -152,9 +153,16 @@ class AssetBase(acp.Abstract):
         if cls.precision != other["precision"]:
             raise ParseError(f"Asset dict precision differ: `{other['precision']}`, when expected `{cls.precision}`.")
 
-    def __assert_same_token(self, other: AssetBase, *, error_detail: str) -> Optional[NoReturn]:
-        if self.token != other.token:
-            raise TypeError(f"Can't {error_detail} assets with different tokens: `{self.token}` and `{other.token}`.")
+    @staticmethod
+    def assert_same_token(first: AssetBase, other: AssetBase, *, error_detail: str) -> Optional[NoReturn]:
+        if first.token != other.token:
+            raise TypeError(f"Can't {error_detail} assets with different tokens: `{first.token}` and `{other.token}`.")
+
+    @staticmethod
+    def assert_is_asset(*other: Any, error_detail: str) -> Optional[NoReturn]:
+        for asset in other:
+            if not isinstance(asset, AssetBase):
+                raise TypeError(f"Can't {error_detail} objects of type `{type(asset)}`.")
 
 
 class Asset:
@@ -183,6 +191,51 @@ class Asset:
         precision: Final[int] = 6
         nai: Final[str] = "@@000000037"
 
+    class Range:
+        """
+        Represents a range of assets by providing the upper and lower bounds for a given value.
+        It functions similarly to the built-in python `range(100, 110)` function, providing a convenient way to
+        represent a range of assets within a specified value range.
+
+        Usage:
+            tt.Asset.Range(lower_limit=tt.Asset.Hive(100), upper_limit=tt.Asset.Hive(110))
+
+        :param lower_limit is required. When tolerance is given it acts as the value to which we refer when specifying
+        the percentage range.
+        :param tolerance: is defined as a positive number, which is a percentage of the upper and lower deviations e.g:
+            asset = tt.Asset.Hive(100)
+            tt.Asset.Range(asset, tolerance=10) -> the range of this asset is from tt.Asset.Hive(90) to inclusive (100)
+
+        Upper limit and tolerance should be used interchangeably.
+        """
+
+        def __init__(
+            self,
+            lower_limit: AssetLimitT,
+            upper_limit: Optional[AssetLimitT] = None,
+            *,
+            tolerance: Union[int, float, None] = None,
+        ):
+            if not upper_limit and not tolerance:
+                raise TypeError("Range has to be specified with either `upper_limit` or `tolerance`")
+
+            if upper_limit and tolerance:
+                raise TypeError("Please choose only one option from `upper_limit` or `tolerance`")
+
+            if tolerance and tolerance < 0:
+                raise TypeError("`tolerance` should be given as an positive number")
+
+            self.__lower_limit = lower_limit if upper_limit else lower_limit - (lower_limit * tolerance / 100)
+            self.__upper_limit = upper_limit if upper_limit else lower_limit + (lower_limit * tolerance / 100)
+            AssetBase.assert_is_asset(self.__lower_limit, self.__upper_limit, error_detail="create range on")
+            AssetBase.assert_same_token(self.__lower_limit, self.__upper_limit, error_detail="create range on")
+            assert self.__lower_limit < self.__upper_limit, "The upper limit cannot be greater than the lower limit"
+
+        def __contains__(self, item: AssetBase):
+            AssetBase.assert_is_asset(item, error_detail="check if asset is in range when")
+            AssetBase.assert_same_token(item, self.__lower_limit, error_detail="check if asset is in range when")
+            return self.__lower_limit <= item <= self.__upper_limit
+
     @classmethod
     def from_(cls, data: Union[str, dict], *, treat_dict_as_testnet_currencies: bool = True) -> AssetBase:
         """