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

coinex/ccxt/static_dependencies/bip/conf/common/bip_coin_conf.py

@@ -0,0 +1,217 @@
+# 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 helper class for generic BIP coins configuration handling."""
+
+# Imports
+from typing import Any, Dict, Optional, Tuple, Type
+
+from ...addr.iaddr_encoder import IAddrEncoder
+from ...bip32 import Bip32Base, Bip32KeyNetVersions, Bip32PublicKey
+from ...utils.conf import CoinNames as UtilsCoinNames
+
+
+class BipCoinFctCallsConf:
+    """Bip coin function calls configuration class."""
+
+    m_fct_names: Tuple[str, ...]
+
+    def __init__(self,
+                 *args: str) -> None:
+        """
+        Construct class.
+
+        Args:
+            args (str): Function names to be called
+        """
+        self.m_fct_names = args
+
+    def ResolveCalls(self,
+                     pub_key: Bip32PublicKey) -> Any:
+        """
+        Resolve function calls and get the result.
+
+        Args:
+            pub_key (Bip32PublicKey object): Bip32PublicKey object
+
+        Returns:
+            Any: Result
+        """
+        res = pub_key
+        for fct_call in self.m_fct_names:
+            res = getattr(res, fct_call)()
+        return res
+
+
+class BipCoinConf:  # pylint: disable=too-many-instance-attributes
+    """Bip coin configuration class."""
+
+    m_coin_names: UtilsCoinNames
+    m_coin_idx: int
+    m_is_testnet: bool
+    m_def_path: str
+    m_key_net_ver: Bip32KeyNetVersions
+    m_wif_net_ver: Optional[bytes]
+    m_bip32_cls: Type[Bip32Base]
+    m_addr_params: Dict[str, Any]
+    # m_addr_cls: Type[IAddrEncoder]
+    m_any_addr_params_fct_call: bool
+
+    def __init__(self,  # pylint: disable=too-many-arguments
+                 coin_names: UtilsCoinNames,
+                 coin_idx: int,
+                 is_testnet: bool,
+                 def_path: str,
+                 key_net_ver: Bip32KeyNetVersions,
+                 wif_net_ver: Optional[bytes],
+                 bip32_cls: Type[Bip32Base],
+                #  addr_cls: Type[IAddrEncoder],
+                 addr_params: Dict[str, Any]) -> None:
+        """
+        Construct class.
+
+        Args:
+            coin_names (CoinNames object)           : Coin names
+            coin_idx (int)                          : Coin index
+            is_testnet (bool)                       : Test net flag
+            def_path (str)                          : Default path
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+            wif_net_ver (bytes)                     : WIF net version, None if not supported
+            bip32_cls (Bip32Base class)             : Bip32 class
+            addr_params (dict)                      : Address parameters
+            addr_cls (IAddrEncoder class)           : Address class
+        """
+        self.m_coin_names = coin_names
+        self.m_coin_idx = coin_idx
+        self.m_is_testnet = is_testnet
+        self.m_def_path = def_path
+        self.m_key_net_ver = key_net_ver
+        self.m_wif_net_ver = wif_net_ver
+        self.m_bip32_cls = bip32_cls
+        self.m_addr_params = addr_params
+        self.m_any_addr_params_fct_call = any(
+            (isinstance(param_val, BipCoinFctCallsConf) for param_val in addr_params.values())
+        )
+        # self.m_addr_cls = addr_cls
+
+    def CoinNames(self) -> UtilsCoinNames:
+        """
+        Get coin names.
+
+        Returns:
+            CoinNames object: CoinNames object
+        """
+        return self.m_coin_names
+
+    def CoinIndex(self) -> int:
+        """
+        Get coin index.
+
+        Returns:
+            int: Coin index
+        """
+        return self.m_coin_idx
+
+    def IsTestNet(self) -> bool:
+        """
+        Get if test net.
+
+        Returns:
+            bool: True if test net, false otherwise
+        """
+        return self.m_is_testnet
+
+    def DefaultPath(self) -> str:
+        """
+        Get the default derivation path.
+
+        Returns:
+            str: Default derivation path
+        """
+        return self.m_def_path
+
+    def KeyNetVersions(self) -> Bip32KeyNetVersions:
+        """
+        Get key net versions.
+
+        Returns:
+            Bip32KeyNetVersions object: Bip32KeyNetVersions object
+        """
+        return self.m_key_net_ver
+
+    def WifNetVersion(self) -> Optional[bytes]:
+        """
+        Get WIF net version.
+
+        Returns:
+            bytes: WIF net version bytes
+            None: If WIF is not supported
+        """
+        return self.m_wif_net_ver
+
+    def Bip32Class(self) -> Type[Bip32Base]:
+        """
+        Get the Bip32 class.
+
+        Returns:
+            Bip32Base class: Bip32Base class
+        """
+        return self.m_bip32_cls
+
+    def AddrParams(self) -> Dict[str, Any]:
+        """
+        Get the address parameters.
+
+        Returns:
+            dict: Address parameters
+        """
+        return self.m_addr_params
+
+    def AddrParamsWithResolvedCalls(self,
+                                    pub_key: Bip32PublicKey) -> Dict[str, Any]:
+        """
+        Get the address parameters with resolved function calls.
+
+        Args:
+            pub_key (Bip32PublicKey object): Bip32PublicKey object
+
+        Returns:
+            dict: Address parameters
+        """
+        addr_params = self.AddrParams()
+
+        # Just use the internal object if nothing to be resolved to avoid creating a new one
+        if not self.m_any_addr_params_fct_call:
+            return addr_params
+
+        # Create a new dictionary with resolved function calls
+        return {
+            param_name: param_val.ResolveCalls(pub_key) if isinstance(param_val, BipCoinFctCallsConf) else param_val
+            for param_name, param_val in addr_params.items()
+        }
+
+    # def AddrClass(self) -> Type[IAddrEncoder]:
+    #     """
+    #     Get the address class.
+
+    #     Returns:
+    #         IAddrEncoder class: Address class
+    #     """
+    #     return self.m_addr_cls

coinex/ccxt/static_dependencies/bip/conf/common/bip_coins.py

@@ -0,0 +1,28 @@
+# 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 generic BIP coins enum."""
+
+# Imports
+from enum import Enum
+
+
+class BipCoins(Enum):
+    """Base enum for bip coins."""

coinex/ccxt/static_dependencies/bip/conf/common/bip_conf_const.py

@@ -0,0 +1,30 @@
+# 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 generic BIP configuration constants."""
+
+# Hardened default path (full)
+DER_PATH_HARDENED_FULL: str = "0'/0'/0'"
+# Hardened default path (mid)
+DER_PATH_HARDENED_MID: str = "0'/0'"
+# Hardened default path (short)
+DER_PATH_HARDENED_SHORT: str = "0'"
+# Non-hardened default path (full)
+DER_PATH_NON_HARDENED_FULL: str = "0'/0/0"

coinex/ccxt/static_dependencies/bip/conf/common/bip_litecoin_conf.py

@@ -0,0 +1,121 @@
+# 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 helper class for Litecoin configuration handling."""
+
+# Imports
+from typing import Any, Dict, Type
+
+from bip_utils.addr import IAddrEncoder
+from bip_utils.bip.bip32 import Bip32KeyNetVersions
+from .bip_coin_conf import Bip32Base, BipCoinConf
+from bip_utils.utils.conf import CoinNames
+
+
+class BipLitecoinConf(BipCoinConf):
+    """
+    Litecoin configuration class.
+    It allows to return different addresses and key net versions depending on the configuration.
+    """
+
+    m_alt_key_net_ver: Bip32KeyNetVersions
+    m_use_alt_key_net_ver: bool
+    m_use_depr_addr: bool
+
+    def __init__(self,  # pylint: disable=too-many-arguments
+                 coin_names: CoinNames,
+                 coin_idx: int,
+                 is_testnet: bool,
+                 def_path: str,
+                 key_net_ver: Bip32KeyNetVersions,
+                 alt_key_net_ver: Bip32KeyNetVersions,
+                 wif_net_ver: bytes,
+                 bip32_cls: Type[Bip32Base],
+                 addr_cls: Type[IAddrEncoder],
+                 addr_params: Dict[str, Any]) -> None:
+        """
+        Construct class.
+
+        Args:
+            coin_names (CoinNames object)               : Coin names
+            coin_idx (int)                              : Coin index
+            is_testnet (bool)                           : Test net flag
+            def_path (str)                              : Default path
+            key_net_ver (Bip32KeyNetVersions object)    : Key net versions
+            alt_key_net_ver (Bip32KeyNetVersions object): Key net versions (alternate)
+            wif_net_ver (bytes)                         : WIF net version
+            bip32_cls (Bip32Base class)                 : Bip32 class
+            addr_params (dict)                          : Address parameters
+            addr_cls (IAddrEncoder class)               : Address class
+        """
+        super().__init__(coin_names=coin_names,
+                         coin_idx=coin_idx,
+                         is_testnet=is_testnet,
+                         def_path=def_path,
+                         key_net_ver=key_net_ver,
+                         wif_net_ver=wif_net_ver,
+                         bip32_cls=bip32_cls,
+                         addr_cls=addr_cls,
+                         addr_params=addr_params)
+
+        self.m_alt_key_net_ver = alt_key_net_ver
+        self.m_use_alt_key_net_ver = False
+        self.m_use_depr_addr = False
+
+    def UseAlternateKeyNetVersions(self,
+                                   value: bool) -> None:
+        """
+        Select if use the alternate key net version.
+
+        Args:
+            value (bool): True for using alternate key net version, false for using the standard one
+        """
+        self.m_use_alt_key_net_ver = value
+
+    def UseDeprecatedAddress(self,
+                             value: bool) -> None:
+        """
+        Select if use the deprecated address.
+
+        Args:
+            value (bool): True for using deprecated address, false for using the standard one
+        """
+        self.m_use_depr_addr = value
+
+    def KeyNetVersions(self) -> Bip32KeyNetVersions:
+        """
+        Get key net versions. It overrides the method in BipCoinConf.
+        Litecoin overrides the method because it can have 2 different key net versions.
+
+        Returns:
+            Bip32KeyNetVersions object: Bip32KeyNetVersions object
+        """
+        return self.m_alt_key_net_ver if self.m_use_alt_key_net_ver else self.m_key_net_ver
+
+    def AddrParams(self) -> Dict[str, Any]:
+        """
+        Get the address parameters. It overrides the method in BipCoinConf.
+
+        Returns:
+            dict: Address parameters
+        """
+        return ({"net_ver": self.m_addr_params["depr_net_ver"]}
+                if self.m_use_depr_addr
+                else {"net_ver": self.m_addr_params["std_net_ver"]})

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

@@ -0,0 +1,42 @@
+# Common
+from .common.ikeys import IPrivateKey, IPublicKey
+from .common.ipoint import IPoint
+
+# Curve
+from .curve.elliptic_curve import EllipticCurve
+from .curve.elliptic_curve_getter import EllipticCurveGetter
+from .curve.elliptic_curve_types import EllipticCurveTypes
+
+# ed25519
+# from .ed25519.ed25519 import Ed25519
+# from .ed25519.ed25519_keys import Ed25519PrivateKey, Ed25519PublicKey
+# from .ed25519.ed25519_point import Ed25519Point
+# from .ed25519.ed25519_utils import Ed25519Utils
+
+# ed25519-blake2b
+# from .ed25519_blake2b.ed25519_blake2b import Ed25519Blake2b
+# from .ed25519_blake2b.ed25519_blake2b_keys import Ed25519Blake2bPrivateKey, Ed25519Blake2bPublicKey
+# from .ed25519_blake2b.ed25519_blake2b_point import Ed25519Blake2bPoint
+
+# ed25519-kholaw
+# from .ed25519_kholaw.ed25519_kholaw import Ed25519Kholaw
+# from .ed25519_kholaw.ed25519_kholaw_keys import Ed25519KholawPrivateKey, Ed25519KholawPublicKey
+# from .ed25519_kholaw.ed25519_kholaw_point import Ed25519KholawPoint
+
+# ed25519-monero
+# from .ed25519_monero.ed25519_monero import Ed25519Monero
+# from .ed25519_monero.ed25519_monero_keys import Ed25519MoneroPrivateKey, Ed25519MoneroPublicKey
+# from .ed25519_monero.ed25519_monero_point import Ed25519MoneroPoint
+
+# nist256p1
+# from .nist256p1.nist256p1 import Nist256p1
+# from .nist256p1.nist256p1_keys import Nist256p1PrivateKey, Nist256p1PublicKey
+# from .nist256p1.nist256p1_point import Nist256p1Point
+
+# secp256k1
+from .secp256k1.secp256k1 import Secp256k1, Secp256k1Point, Secp256k1PrivateKey, Secp256k1PublicKey
+
+# sr25519
+# from .sr25519.sr25519 import Sr25519
+# from .sr25519.sr25519_keys import Sr25519PrivateKey, Sr25519PublicKey
+# from .sr25519.sr25519_point import Sr25519Point

coinex/ccxt/static_dependencies/bip/ecc/common/dummy_point.py

@@ -0,0 +1,219 @@
+# 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 helper class for representing a dummy point."""
+
+# Imports
+from abc import ABC
+from typing import Any
+
+from bip_utils.ecc.common.ipoint import IPoint
+from bip_utils.utils.misc import BytesUtils, DataBytes, IntegerUtils
+
+
+class DummyPointConst:
+    """Class container for dummy point constants."""
+
+    # Point coordinate length in bytes
+    POINT_COORD_BYTE_LEN: int = 32
+
+
+class DummyPoint(IPoint, ABC):
+    """Dummy point class."""
+
+    m_x: int
+    m_y: int
+
+    @classmethod
+    def FromBytes(cls,
+                  point_bytes: bytes) -> IPoint:
+        """
+        Construct class from point bytes.
+
+        Args:
+            point_bytes (bytes): Point bytes
+
+        Returns:
+            IPoint: IPoint object
+        """
+        return cls(
+            (
+                BytesUtils.ToInteger(point_bytes[:DummyPointConst.POINT_COORD_BYTE_LEN]),
+                BytesUtils.ToInteger(point_bytes[DummyPointConst.POINT_COORD_BYTE_LEN:])
+            )
+        )
+
+    @classmethod
+    def FromCoordinates(cls,
+                        x: int,
+                        y: int) -> IPoint:
+        """
+        Construct class from point coordinates.
+
+        Args:
+            x (int): X coordinate of the point
+            y (int): Y coordinate of the point
+
+        Returns:
+            IPoint: IPoint object
+        """
+        return cls((x, y))
+
+    def __init__(self,
+                 point_obj: Any) -> None:
+        """
+        Construct class from point object.
+
+        Args:
+            point_obj (class): Point object
+
+        Raises:
+            TypeError: If point object is not of the correct type
+        """
+        if (not isinstance(point_obj, tuple)
+                or len(point_obj) != 2
+                or not isinstance(point_obj[0], int)
+                or not isinstance(point_obj[1], int)):
+            raise TypeError("Invalid point object type")
+        self.m_x = point_obj[0]
+        self.m_y = point_obj[1]
+
+    @staticmethod
+    def CoordinateLength() -> int:
+        """
+        Get the coordinate length.
+
+        Returns:
+           int: Coordinate key length
+        """
+        return DummyPointConst.POINT_COORD_BYTE_LEN
+
+    def UnderlyingObject(self) -> Any:
+        """
+        Get the underlying object.
+
+        Returns:
+           Any: Underlying object
+        """
+        return None
+
+    def X(self) -> int:
+        """
+        Get point X coordinate.
+
+        Returns:
+           int: Point X coordinate
+        """
+        return self.m_x
+
+    def Y(self) -> int:
+        """
+        Get point Y coordinate.
+
+        Returns:
+           int: Point Y coordinate
+        """
+        return self.m_y
+
+    def Raw(self) -> DataBytes:
+        """
+        Return the point raw bytes.
+
+        Returns:
+            DataBytes object: DataBytes object
+        """
+        x_bytes = IntegerUtils.ToBytes(self.m_x, bytes_num=DummyPointConst.POINT_COORD_BYTE_LEN)
+        y_bytes = IntegerUtils.ToBytes(self.m_y, bytes_num=DummyPointConst.POINT_COORD_BYTE_LEN)
+
+        return DataBytes(x_bytes + y_bytes)
+
+    def RawEncoded(self) -> DataBytes:
+        """
+        Return the encoded point raw bytes.
+
+        Returns:
+            DataBytes object: DataBytes object
+        """
+        return self.Raw()
+
+    def RawDecoded(self) -> DataBytes:
+        """
+        Return the decoded point raw bytes.
+
+        Returns:
+            DataBytes object: DataBytes object
+        """
+        return self.Raw()
+
+    def __add__(self,
+                point: IPoint) -> IPoint:
+        """
+        Add point to another point.
+
+        Args:
+            point (IPoint object): IPoint object
+
+        Returns:
+            IPoint object: IPoint object
+        """
+        return self.__class__(
+            (self.m_x + point.X(), self.m_y + point.Y())
+        )
+
+    def __radd__(self,
+                 point: IPoint) -> IPoint:
+        """
+        Add point to another point.
+
+        Args:
+            point (IPoint object): IPoint object
+
+        Returns:
+            IPoint object: IPoint object
+        """
+        return self.__add__(point)
+
+    def __mul__(self,
+                scalar: int) -> IPoint:
+        """
+        Multiply point by a scalar.
+
+        Args:
+            scalar (int): scalar
+
+        Returns:
+            IPoint object: IPoint object
+        """
+        return self.__class__(
+            (self.m_x * scalar, self.m_y * scalar)
+        )
+
+    def __rmul__(self,
+                 scalar: int) -> IPoint:
+        """
+        Multiply point by a scalar.
+
+        Args:
+            scalar (int): scalar
+
+        Returns:
+            IPoint object: IPoint object
+        """
+        return self.__mul__(scalar)