coinex-api 0.0.89__py3-none-any.whl → 0.0.110__py3-none-any.whl

coinex/ccxt/base/types.py

@@ -4,14 +4,14 @@ from typing import Union, List, Optional, Any as PythonAny
 from decimal import Decimal
 
 
-if sys.version_info.minor >= 8:
+if sys.version_info >= (3, 8):
     from typing import TypedDict, Literal, Dict
 else:
     from typing import Dict
     from typing_extensions import Literal
     TypedDict = Dict
 
-if sys.version_info.minor >= 11:
+if sys.version_info >= (3, 11):
     from typing import NotRequired
 else:
     from typing_extensions import NotRequired
@@ -191,6 +191,8 @@ class Liquidation(TypedDict):
     baseValue: Num
     quoteValue: Num
     side: OrderSide
+    contracts: Num
+    contractSize: Num
 
 
 class FundingHistory(TypedDict):
@@ -500,6 +502,13 @@ class FundingRate(TypedDict):
     info: Dict[str, Any]
     interval: Str
 
+class FundingRateHistory(TypedDict):
+    symbol: Str
+    timestamp: Int
+    fundingRate: Num
+    datetime: Str
+    info: Dict[str, Any]
+
 class OpenInterest(TypedDict):
     symbol: Str
     openInterestAmount: Num

coinex/ccxt/coinex.py

@@ -1600,7 +1600,7 @@ class coinex(Exchange, ImplicitAPI):
             self.safe_number(ohlcv, 'value'),
         ]
 
-    def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
+    def fetch_ohlcv(self, symbol: str, timeframe: str = '1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
 
@@ -2616,7 +2616,7 @@ class coinex(Exchange, ImplicitAPI):
             results.append(order)
         return results
 
-    def cancel_orders(self, ids, symbol: Str = None, params={}):
+    def cancel_orders(self, ids: List[str], symbol: Str = None, params={}):
         """
         cancel multiple orders
 

coinex/ccxt/pro/__init__.py

@@ -8,7 +8,7 @@ sys.modules['ccxt'] = ccxt_module
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.5.5'
+__version__ = '4.5.25'
 
 # ----------------------------------------------------------------------------
 

coinex/ccxt/pro/coinex.py

@@ -102,8 +102,10 @@ class coinex(coinexAsync):
         })
 
     def request_id(self):
+        self.lock_id()
         requestId = self.sum(self.safe_integer(self.options, 'requestId', 0), 1)
         self.options['requestId'] = requestId
+        self.unlock_id()
         return requestId
 
     def handle_ticker(self, client: Client, message):
@@ -165,7 +167,7 @@ class coinex(coinexAsync):
         defaultType = self.safe_string(self.options, 'defaultType')
         data = self.safe_dict(message, 'data', {})
         rawTickers = self.safe_list(data, 'state_list', [])
-        newTickers = []
+        newTickers = {}
         for i in range(0, len(rawTickers)):
             entry = rawTickers[i]
             marketId = self.safe_string(entry, 'market')
@@ -173,7 +175,7 @@ class coinex(coinexAsync):
             market = self.safe_market(marketId, None, None, defaultType)
             parsedTicker = self.parse_ws_ticker(entry, market)
             self.tickers[symbol] = parsedTicker
-            newTickers.append(parsedTicker)
+            newTickers[symbol] = parsedTicker
         messageHashes = self.find_message_hashes(client, 'tickers::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]
@@ -643,6 +645,7 @@ class coinex(coinexAsync):
                 market = self.market(symbol)
                 messageHashes.append('tickers::' + market['symbol'])
         else:
+            marketIds = []
             messageHashes.append('tickers')
         type = None
         type, params = self.handle_market_type_and_params('watchTickers', market, params)
@@ -705,13 +708,13 @@ class coinex(coinexAsync):
         type = None
         type, params = self.handle_market_type_and_params(callerMethodName, market, params)
         url = self.urls['api']['ws'][type]
-        subscriptionHashes = ['trades']
+        # subscriptionHashes = ['trades']
         subscribe: dict = {
             'method': 'deals.subscribe',
             'params': {'market_list': subscribedSymbols},
             'id': self.request_id(),
         }
-        trades = await self.watch_multiple(url, messageHashes, self.deep_extend(subscribe, params), subscriptionHashes)
+        trades = await self.watch_multiple(url, messageHashes, self.deep_extend(subscribe, params), messageHashes)
         if self.newUpdates:
             return trades
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
@@ -762,9 +765,9 @@ class coinex(coinexAsync):
             'params': {'market_list': marketList},
             'id': self.request_id(),
         }
-        subscriptionHashes = self.hash(self.encode(self.json(watchOrderBookSubscriptions)), 'sha256')
+        # subscriptionHashes = self.hash(self.encode(self.json(watchOrderBookSubscriptions)), 'sha256')
         url = self.urls['api']['ws'][type]
-        orderbooks = await self.watch_multiple(url, messageHashes, self.deep_extend(subscribe, params), subscriptionHashes)
+        orderbooks = await self.watch_multiple(url, messageHashes, self.deep_extend(subscribe, params), messageHashes)
         if self.newUpdates:
             return orderbooks
         return orderbooks.limit()
@@ -1343,7 +1346,7 @@ class coinex(coinexAsync):
         time = self.milliseconds()
         timestamp = str(time)
         messageHash = 'authenticated'
-        future = client.future(messageHash)
+        future = client.reusableFuture(messageHash)
         authenticated = self.safe_value(client.subscriptions, messageHash)
         if authenticated is not None:
             return await future

coinex/ccxt/static_dependencies/bip/__init__.py

@@ -0,0 +1,6 @@
+from .bip32 import *
+from .bip44 import *
+from .utils import *
+from .conf import *
+
+__all__ = [ 'bip32', 'bip44', 'utils', 'conf' ]

coinex/ccxt/static_dependencies/bip/addr/P2PKH_addr.py

@@ -0,0 +1,205 @@
+# Copyright (c) 2021 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Module for P2PKH address encoding/decoding."""
+
+# Imports
+from enum import Enum, auto, unique
+from typing import Any, Union
+
+from .addr_dec_utils import AddrDecUtils
+from .addr_key_validator import AddrKeyValidator
+from .iaddr_decoder import IAddrDecoder
+from .iaddr_encoder import IAddrEncoder
+from ..base58 import Base58Alphabets, Base58ChecksumError, Base58Decoder, Base58Encoder
+from ..bech32 import BchBech32Decoder, BchBech32Encoder, Bech32ChecksumError
+from ..ecc import IPublicKey
+from ..utils.crypto import Hash160
+from ..utils.misc import BytesUtils
+
+
+@unique
+class P2PKHPubKeyModes(Enum):
+    """Enumerative for P2PKH public key modes."""
+
+    COMPRESSED = auto()
+    UNCOMPRESSED = auto()
+
+
+class P2PKHAddrDecoder(IAddrDecoder):
+    """
+    P2PKH address decoder class.
+    It allows the Pay-to-Public-Key-Hash address decoding.
+    """
+
+    @staticmethod
+    def DecodeAddr(addr: str,
+                   **kwargs: Any) -> bytes:
+        """
+        Decode a P2PKH address to bytes.
+
+        Args:
+            addr (str): Address string
+
+        Other Parameters:
+            net_ver (bytes)                        : Expected net address version
+            base58_alph (Base58Alphabets, optional): Base58 alphabet (default: Bitcoin alphabet)
+
+        Returns:
+            bytes: Public key hash bytes
+
+        Raises:
+            ValueError: If the address encoding is not valid
+        """
+        net_ver_bytes = kwargs["net_ver"]
+        base58_alph = kwargs.get("base58_alph", Base58Alphabets.BITCOIN)
+
+        try:
+            addr_dec_bytes = Base58Decoder.CheckDecode(addr, base58_alph)
+        except Base58ChecksumError as ex:
+            raise ValueError("Invalid base58 checksum") from ex
+
+        # Validate length
+        AddrDecUtils.ValidateLength(addr_dec_bytes,
+                                    Hash160.DigestSize() + len(net_ver_bytes))
+        # Validate and remove prefix
+        return AddrDecUtils.ValidateAndRemovePrefix(addr_dec_bytes, net_ver_bytes)
+
+
+class P2PKHAddrEncoder(IAddrEncoder):
+    """
+    P2PKH address encoder class.
+    It allows the Pay-to-Public-Key-Hash address encoding.
+    """
+
+    @staticmethod
+    def EncodeKey(pub_key: Union[bytes, IPublicKey],
+                  **kwargs: Any) -> str:
+        """
+        Encode a public key to P2PKH address.
+
+        Args:
+            pub_key (bytes or IPublicKey): Public key bytes or object
+
+        Other Parameters:
+            net_ver (bytes)                          : Net address version
+            base58_alph (Base58Alphabets, optional)  : Base58 alphabet, Bitcoin alphabet by default
+            pub_key_mode (P2PKHPubKeyModes, optional): Public key mode, compressed key by default
+
+        Returns:
+            str: Address string
+
+        Raises:
+            ValueError: If the public key is not valid
+            TypeError: If the public key is not secp256k1
+        """
+        net_ver_bytes = kwargs["net_ver"]
+        base58_alph = kwargs.get("base58_alph", Base58Alphabets.BITCOIN)
+        pub_key_mode = kwargs.get("pub_key_mode", P2PKHPubKeyModes.COMPRESSED)
+
+        pub_key_obj = AddrKeyValidator.ValidateAndGetSecp256k1Key(pub_key)
+        pub_key_bytes = (pub_key_obj.RawCompressed().ToBytes()
+                         if pub_key_mode == P2PKHPubKeyModes.COMPRESSED
+                         else pub_key_obj.RawUncompressed().ToBytes())
+
+        return Base58Encoder.CheckEncode(net_ver_bytes + Hash160.QuickDigest(pub_key_bytes), base58_alph)
+
+
+class BchP2PKHAddrDecoder(IAddrDecoder):
+    """
+    Bitcoin Cash P2PKH address decoder class.
+    It allows the Bitcoin Cash P2PKH decoding.
+    """
+
+    @staticmethod
+    def DecodeAddr(addr: str,
+                   **kwargs: Any) -> bytes:
+        """
+        Decode a Bitcoin Cash P2PKH address to bytes.
+
+        Args:
+            addr (str): Address string
+
+        Other Parameters:
+            hrp (str)      : Expected HRP
+            net_ver (bytes): Expected net address version
+
+        Returns:
+            bytes: Public key hash bytes
+
+        Raises:
+            ValueError: If the address encoding is not valid
+        """
+        hrp = kwargs["hrp"]
+        net_ver_bytes = kwargs["net_ver"]
+
+        try:
+            net_ver_bytes_got, addr_dec_bytes = BchBech32Decoder.Decode(hrp, addr)
+        except Bech32ChecksumError as ex:
+            raise ValueError("Invalid bech32 checksum") from ex
+
+        # Check net version
+        if net_ver_bytes != net_ver_bytes_got:
+            raise ValueError(f"Invalid net version (expected {BytesUtils.ToHexString(net_ver_bytes)}, "
+                             f"got {BytesUtils.ToHexString(net_ver_bytes_got)})")
+        # Validate length
+        AddrDecUtils.ValidateLength(addr_dec_bytes,
+                                    Hash160.DigestSize())
+        return addr_dec_bytes
+
+
+class BchP2PKHAddrEncoder(IAddrEncoder):
+    """
+    Bitcoin Cash P2PKH address encoder class.
+    It allows the Bitcoin Cash P2PKH encoding.
+    """
+
+    @staticmethod
+    def EncodeKey(pub_key: Union[bytes, IPublicKey],
+                  **kwargs: Any) -> str:
+        """
+        Encode a public key to Bitcoin Cash P2PKH address.
+
+        Args:
+            pub_key (bytes or IPublicKey): Public key bytes or object
+
+        Other Parameters:
+            hrp (str)      : HRP
+            net_ver (bytes): Net address version
+
+        Returns:
+            str: Address string
+
+        Raises:
+            ValueError: If the public key is not valid
+            TypeError: If the public key is not secp256k1
+        """
+        hrp = kwargs["hrp"]
+        net_ver_bytes = kwargs["net_ver"]
+
+        pub_key_obj = AddrKeyValidator.ValidateAndGetSecp256k1Key(pub_key)
+        return BchBech32Encoder.Encode(hrp,
+                                       net_ver_bytes,
+                                       Hash160.QuickDigest(pub_key_obj.RawCompressed().ToBytes()))
+
+
+# Deprecated: only for compatibility, Encoder classes shall be used instead
+P2PKHAddr = P2PKHAddrEncoder
+BchP2PKHAddr = BchP2PKHAddrEncoder

coinex/ccxt/static_dependencies/bip/addr/__init__.py

@@ -0,0 +1,5 @@
+from .iaddr_encoder import IAddrEncoder
+from .P2PKH_addr import (
+    BchP2PKHAddr, BchP2PKHAddrDecoder, BchP2PKHAddrEncoder, P2PKHAddr, P2PKHAddrDecoder, P2PKHAddrEncoder,
+    P2PKHPubKeyModes
+)

coinex/ccxt/static_dependencies/bip/addr/addr_dec_utils.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2021 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Module with utility functions for address decoding."""
+
+# Imports
+from typing import Callable, Tuple, Type, TypeVar, Union
+
+from ..ecc import IPublicKey
+from ..utils.misc import BytesUtils
+
+
+BytesOrStr = TypeVar("BytesOrStr", bytes, str)
+
+
+class AddrDecUtils:
+    """Class container for address decoding utility functions."""
+
+    @staticmethod
+    def ValidateAndRemovePrefix(addr: BytesOrStr,
+                                prefix: BytesOrStr) -> BytesOrStr:
+        """
+        Validate and remove prefix from an address.
+
+        Args:
+            addr (bytes or str)  : Address string or bytes
+            prefix (bytes or str): Address prefix
+
+        Returns:
+            bytes or str: Address string or bytes with prefix removed
+
+        Raises:
+            ValueError: If the prefix is not valid
+        """
+        prefix_got = addr[:len(prefix)]
+        if prefix != prefix_got:
+            raise ValueError(f"Invalid prefix (expected {prefix!r}, got {prefix_got!r})")
+        return addr[len(prefix):]
+
+    @staticmethod
+    def ValidateLength(addr: Union[bytes, str],
+                       len_exp: int) -> None:
+        """
+        Validate address length.
+
+        Args:
+            addr (str)   : Address string or bytes
+            len_exp (int): Expected address length
+
+        Raises:
+            ValueError: If the length is not valid
+        """
+        if len(addr) != len_exp:
+            raise ValueError(f"Invalid length (expected {len_exp}, got {len(addr)})")
+
+    @staticmethod
+    def ValidatePubKey(pub_key_bytes: bytes,
+                       pub_key_cls: Type[IPublicKey]) -> None:
+        """
+        Validate address length.
+
+        Args:
+            pub_key_bytes (bytes)   : Public key bytes
+            pub_key_cls (IPublicKey): Public key class type
+
+        Raises:
+            ValueError: If the public key is not valid
+        """
+        if not pub_key_cls.IsValidBytes(pub_key_bytes):
+            raise ValueError(f"Invalid {pub_key_cls.CurveType()} "
+                             f"public key {BytesUtils.ToHexString(pub_key_bytes)}")
+
+    @staticmethod
+    def ValidateChecksum(payload_bytes: bytes,
+                         checksum_bytes_exp: bytes,
+                         checksum_fct: Callable[[bytes], bytes]) -> None:
+        """
+        Validate address checksum.
+
+        Args:
+            payload_bytes (bytes)     : Payload bytes
+            checksum_bytes_exp (bytes): Expected checksum bytes
+            checksum_fct (function)   : Function for computing checksum
+
+        Raises:
+            ValueError: If the computed checksum is not equal tot he specified one
+        """
+        checksum_bytes_got = checksum_fct(payload_bytes)
+        if checksum_bytes_exp != checksum_bytes_got:
+            raise ValueError(f"Invalid checksum (expected {BytesUtils.ToHexString(checksum_bytes_exp)}, "
+                             f"got {BytesUtils.ToHexString(checksum_bytes_got)})")
+
+    @staticmethod
+    def SplitPartsByChecksum(addr_bytes: bytes,
+                             checksum_len: int) -> Tuple[bytes, bytes]:
+        """
+        Split address in two parts, considering the checksum at the end of it.
+
+        Args:
+            addr_bytes (bytes): Address bytes
+            checksum_len (int): Checksum length
+
+        Returns:
+            tuple[bytes, bytes]: Payload bytes (index 0) and checksum bytes (index 1)
+        """
+        checksum_bytes = addr_bytes[-1 * checksum_len:]
+        payload_bytes = addr_bytes[:-1 * checksum_len]
+        return payload_bytes, checksum_bytes

coinex/ccxt/static_dependencies/bip/addr/addr_key_validator.py

@@ -0,0 +1,162 @@
+# Copyright (c) 2021 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""Module with utility functions for validating address public keys."""
+
+# Imports
+from typing import Type, Union
+
+from ..ecc import (
+    Secp256k1PublicKey, IPublicKey,
+    # Ed25519Blake2bPublicKey, Ed25519MoneroPublicKey, Ed25519PublicKey, EllipticCurveGetter,
+    # Nist256p1PublicKey, Secp256k1PublicKey, Sr25519PublicKey
+)
+
+
+class AddrKeyValidator:
+    """Class container for address utility functions."""
+
+    # @staticmethod
+    # def ValidateAndGetEd25519Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a ed25519 public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not ed25519
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Ed25519PublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetEd25519Blake2bKey(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a ed25519-blake2b public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not ed25519-blake2b
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Ed25519Blake2bPublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetEd25519MoneroKey(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a ed25519-monero public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not ed25519-monero
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Ed25519MoneroPublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetNist256p1Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a nist256p1 public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not nist256p1
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Nist256p1PublicKey)
+
+    @staticmethod
+    def ValidateAndGetSecp256k1Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+        """
+        Validate and get a secp256k1 public key.
+
+        Args:
+            pub_key (bytes or IPublicKey object): Public key bytes or object
+
+        Returns:
+            IPublicKey object: IPublicKey object
+
+        Raises:
+            TypeError: If the public key is not secp256k1
+            ValueError: If the public key is not valid
+        """
+        return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Secp256k1PublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetSr25519Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a sr25519 public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not sr25519
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Sr25519PublicKey)
+
+    @staticmethod
+    def __ValidateAndGetGenericKey(pub_key: Union[bytes, IPublicKey],
+                                   pub_key_cls: Type[IPublicKey]) -> IPublicKey:
+        """
+        Validate and get a generic public key.
+
+        Args:
+            pub_key (bytes or IPublicKey object): Public key bytes or object
+            pub_key_cls (IPublicKey)            : Public key class type
+
+        Returns:
+            IPublicKey object: IPublicKey object
+
+        Raises:
+            TypeError: If the public key is not of the correct class type
+            ValueError: If the public key is not valid
+        """
+        if isinstance(pub_key, bytes):
+            pub_key = pub_key_cls.FromBytes(pub_key)
+        elif not isinstance(pub_key, pub_key_cls):
+            curve = EllipticCurveGetter.FromType(pub_key_cls.CurveType())
+            raise TypeError(f"A {curve.Name()} public key is required"
+                            f"(expected: {pub_key_cls}, got: {type(pub_key)}")
+
+        return pub_key