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

coinex/ccxt/static_dependencies/bip/bip32/bip32_keys.py

@@ -0,0 +1,457 @@
+# 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 BIP32 keys handling."""
+
+# Imports
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from functools import lru_cache
+from typing import Union
+
+from .bip32_ex import Bip32KeyError
+from .bip32_key_data import Bip32ChainCode, Bip32FingerPrint, Bip32KeyData
+from .bip32_key_net_ver import Bip32KeyNetVersions
+from .bip32_key_ser import Bip32PrivateKeySerializer, Bip32PublicKeySerializer
+from ..ecc import EllipticCurve, EllipticCurveGetter, EllipticCurveTypes, IPoint, IPrivateKey, IPublicKey
+from ..utils.crypto import Hash160
+from ..utils.misc import DataBytes
+
+
+class _Bip32KeyBase(ABC):
+    """Base class for a generic BIP32 key."""
+
+    m_curve: EllipticCurve
+    m_curve_type: EllipticCurveTypes
+    m_key_data: Bip32KeyData
+    m_key_net_ver: Bip32KeyNetVersions
+
+    def __init__(self,
+                 key_data: Bip32KeyData,
+                 key_net_ver: Bip32KeyNetVersions,
+                 curve_type: EllipticCurveTypes) -> None:
+        """
+        Construct class.
+
+        Args:
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+            curve_type (EllipticCurveTypes)         : Elliptic curve type
+        """
+        self.m_curve = EllipticCurveGetter.FromType(curve_type)
+        self.m_curve_type = curve_type
+        self.m_key_data = key_data
+        self.m_key_net_ver = key_net_ver
+
+    def Curve(self) -> EllipticCurve:
+        """
+        Return key elliptic curve.
+
+        Returns:
+            EllipticCurve object: EllipticCurve object
+        """
+        return self.m_curve
+
+    def CurveType(self) -> EllipticCurveTypes:
+        """
+        Return key elliptic curve type.
+
+        Returns:
+            EllipticCurveTypes: Elliptic curve type
+        """
+        return self.m_curve_type
+
+    def Data(self) -> Bip32KeyData:
+        """
+        Return key data.
+
+        Returns:
+            BipKeyData object: BipKeyData object
+        """
+        return self.m_key_data
+
+    def ChainCode(self) -> Bip32ChainCode:
+        """
+        Return the chain code.
+
+        Returns:
+            Bip32ChainCode object: Bip32ChainCode object
+        """
+        return self.Data().ChainCode()
+
+    def KeyNetVersions(self) -> Bip32KeyNetVersions:
+        """
+        Get key net versions.
+
+        Returns:
+            Bip32KeyNetVersions object: Bip32KeyNetVersions object
+        """
+        return self.m_key_net_ver
+
+    @abstractmethod
+    def ToExtended(self) -> str:
+        """
+        Return key in serialized extended format.
+
+        Returns:
+            str: Key in serialized extended format
+        """
+
+
+class Bip32PublicKey(_Bip32KeyBase):
+    """
+    BIP32 public key class.
+    It represents a public key used by BIP32 with all the related data (e.g. depth, chain code, etc...).
+    """
+
+    m_pub_key: IPublicKey
+
+    @classmethod
+    def FromBytesOrKeyObject(cls,
+                             pub_key: Union[bytes, IPoint, IPublicKey],
+                             key_data: Bip32KeyData,
+                             key_net_ver: Bip32KeyNetVersions,
+                             curve_type: EllipticCurveTypes) -> Bip32PublicKey:
+        """
+        Get the public key from key bytes or object.
+
+        Args:
+            pub_key (bytes, IPoint or IPublicKey)   : Public key
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+            curve_type (EllipticCurveTypes)         : Elliptic curve type
+
+        Returns:
+            Bip32PublicKey object: Bip32PublicKey object
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        if isinstance(pub_key, bytes):
+            return cls.FromBytes(pub_key, key_data, key_net_ver, curve_type)
+        if isinstance(pub_key, IPoint):
+            return cls.FromPoint(pub_key, key_data, key_net_ver)
+        return cls(pub_key, key_data, key_net_ver)
+
+    @classmethod
+    def FromBytes(cls,
+                  key_bytes: bytes,
+                  key_data: Bip32KeyData,
+                  key_net_ver: Bip32KeyNetVersions,
+                  curve_type: EllipticCurveTypes) -> Bip32PublicKey:
+        """
+        Create from bytes.
+
+        Args:
+            key_bytes (bytes)                       : Key bytes
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+            curve_type (EllipticCurveTypes)         : Elliptic curve type
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        return cls(cls.__KeyFromBytes(key_bytes, curve_type),
+                   key_data,
+                   key_net_ver)
+
+    @classmethod
+    def FromPoint(cls,
+                  key_point: IPoint,
+                  key_data: Bip32KeyData,
+                  key_net_ver: Bip32KeyNetVersions) -> Bip32PublicKey:
+        """
+        Create from point.
+
+        Args:
+            key_point (IPoint object)               : Key point
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        return cls(cls.__KeyFromPoint(key_point),
+                   key_data,
+                   key_net_ver)
+
+    def __init__(self,
+                 pub_key: IPublicKey,
+                 key_data: Bip32KeyData,
+                 key_net_ver: Bip32KeyNetVersions) -> None:
+        """
+        Construct class.
+
+        Args:
+            pub_key (IPublicKey object)             : Key object
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+        """
+        super().__init__(key_data, key_net_ver, pub_key.CurveType())
+        self.m_pub_key = pub_key
+
+    def KeyObject(self) -> IPublicKey:
+        """
+        Return the key object.
+
+        Returns:
+            IPublicKey object: Key object
+        """
+        return self.m_pub_key
+
+    @lru_cache()
+    def RawCompressed(self) -> DataBytes:
+        """
+        Return raw compressed public key.
+
+        Returns:
+            DataBytes object: DataBytes object
+        """
+        return self.m_pub_key.RawCompressed()
+
+    @lru_cache()
+    def RawUncompressed(self) -> DataBytes:
+        """
+        Return raw uncompressed public key.
+
+        Returns:
+            DataBytes object: DataBytes object
+        """
+        return self.m_pub_key.RawUncompressed()
+
+    def Point(self) -> IPoint:
+        """
+        Get public key point.
+
+        Returns:
+            IPoint object: IPoint object
+        """
+        return self.m_pub_key.Point()
+
+    @lru_cache()
+    def FingerPrint(self) -> Bip32FingerPrint:
+        """
+        Get key fingerprint.
+
+        Returns:
+            bytes: Key fingerprint bytes
+        """
+        return Bip32FingerPrint(self.KeyIdentifier())
+
+    @lru_cache()
+    def KeyIdentifier(self) -> bytes:
+        """
+        Get key identifier.
+
+        Returns:
+            bytes: Key identifier bytes
+        """
+        return Hash160.QuickDigest(self.m_pub_key.RawCompressed().ToBytes())
+
+    @lru_cache()
+    def ToExtended(self) -> str:
+        """
+        Return key in serialized extended format.
+
+        Returns:
+            str: Key in serialized extended format
+        """
+        return Bip32PublicKeySerializer.Serialize(self.m_pub_key,
+                                                  self.m_key_data,
+                                                  self.m_key_net_ver)
+
+    @staticmethod
+    def __KeyFromBytes(key_bytes: bytes,
+                       curve_type: EllipticCurveTypes) -> IPublicKey:
+        """
+        Construct key from bytes.
+
+        Args:
+            key_bytes (bytes)              : Key bytes
+            curve_type (EllipticCurveTypes): Elliptic curve type
+
+        Returns:
+            IPublicKey object: IPublicKey object
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        try:
+            curve = EllipticCurveGetter.FromType(curve_type)
+            return curve.PublicKeyClass().FromBytes(key_bytes)
+        except ValueError as ex:
+            raise Bip32KeyError("Invalid public key bytes") from ex
+
+    @staticmethod
+    def __KeyFromPoint(key_point: IPoint) -> IPublicKey:
+        """
+        Construct key from point.
+
+        Args:
+            key_point (IPoint object): Key point
+
+        Returns:
+            IPublicKey object: IPublicKey object
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        try:
+            curve = EllipticCurveGetter.FromType(key_point.CurveType())
+            return curve.PublicKeyClass().FromPoint(key_point)
+        except ValueError as ex:
+            raise Bip32KeyError("Invalid public key point") from ex
+
+
+class Bip32PrivateKey(_Bip32KeyBase):
+    """
+    BIP32 private key class.
+    It represents a private key used by BIP32 with all the related data (e.g. depth, chain code, etc...).
+    """
+
+    m_priv_key: IPrivateKey
+
+    @classmethod
+    def FromBytesOrKeyObject(cls,
+                             priv_key: Union[bytes, IPrivateKey],
+                             key_data: Bip32KeyData,
+                             key_net_ver: Bip32KeyNetVersions,
+                             curve_type: EllipticCurveTypes) -> Bip32PrivateKey:
+        """
+        Get the public key from key bytes or object.
+
+        Args:
+            priv_key (bytes or IPrivateKey)         : Private key
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+            curve_type (EllipticCurveTypes)         : Elliptic curve type
+
+        Returns:
+            Bip32PrivateKey object: Bip32PrivateKey object
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        return (cls.FromBytes(priv_key, key_data, key_net_ver, curve_type)
+                if isinstance(priv_key, bytes)
+                else cls(priv_key, key_data, key_net_ver))
+
+    @classmethod
+    def FromBytes(cls,
+                  key_bytes: bytes,
+                  key_data: Bip32KeyData,
+                  key_net_ver: Bip32KeyNetVersions,
+                  curve_type: EllipticCurveTypes) -> Bip32PrivateKey:
+        """
+        Create from bytes.
+
+        Args:
+            key_bytes (bytes)                       : Key bytes
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+            curve_type (EllipticCurveTypes)         : Elliptic curve type
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        return cls(cls.__KeyFromBytes(key_bytes, curve_type),
+                   key_data,
+                   key_net_ver)
+
+    def __init__(self,
+                 priv_key: IPrivateKey,
+                 key_data: Bip32KeyData,
+                 key_net_ver: Bip32KeyNetVersions) -> None:
+        """
+        Construct class.
+
+        Args:
+            priv_key (IPrivateKey object)           : Key object
+            key_data (Bip32KeyData object)          : Key data
+            key_net_ver (Bip32KeyNetVersions object): Key net versions
+        """
+        super().__init__(key_data, key_net_ver, priv_key.CurveType())
+        self.m_priv_key = priv_key
+
+    def KeyObject(self) -> IPrivateKey:
+        """
+        Return the key object.
+
+        Returns:
+            IPrivateKey object: Key object
+        """
+        return self.m_priv_key
+
+    @lru_cache()
+    def Raw(self) -> DataBytes:
+        """
+        Return raw private key.
+
+        Returns:
+            DataBytes object: DataBytes object
+        """
+        return self.m_priv_key.Raw()
+
+    @lru_cache()
+    def PublicKey(self) -> Bip32PublicKey:
+        """
+        Get the public key correspondent to the private one.
+
+        Returns:
+            Bip32PublicKey object: Bip32PublicKey object
+        """
+        return Bip32PublicKey(self.m_priv_key.PublicKey(),
+                              self.m_key_data,
+                              self.m_key_net_ver)
+
+    @lru_cache()
+    def ToExtended(self) -> str:
+        """
+        Return key in serialized extended format.
+
+        Returns:
+            str: Key in serialized extended format
+        """
+        return Bip32PrivateKeySerializer.Serialize(self.m_priv_key,
+                                                   self.m_key_data,
+                                                   self.m_key_net_ver)
+
+    @staticmethod
+    def __KeyFromBytes(key_bytes: bytes,
+                       curve_type: EllipticCurveTypes) -> IPrivateKey:
+        """
+        Construct key from bytes.
+
+        Args:
+            key_bytes (bytes)              : Key bytes
+            curve_type (EllipticCurveTypes): Elliptic curve type
+
+        Returns:
+            IPrivateKey object: IPrivateKey object
+
+        Raises:
+            Bip32KeyError: If the key constructed from the bytes is not valid
+        """
+        try:
+            curve = EllipticCurveGetter.FromType(curve_type)
+            return curve.PrivateKeyClass().FromBytes(key_bytes)
+        except ValueError as ex:
+            raise Bip32KeyError("Invalid private key bytes") from ex

coinex/ccxt/static_dependencies/bip/bip32/bip32_path.py

@@ -0,0 +1,247 @@
+# 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 BIP32 paths parsing and handling."""
+
+# Import
+from __future__ import annotations
+
+from typing import Iterator, List, Optional, Sequence, Tuple, Union
+
+from .bip32_ex import Bip32PathError
+from .bip32_key_data import Bip32KeyIndex
+
+
+class Bip32PathConst:
+    """Class container for BIP32 path constants."""
+
+    # Hardened characters
+    HARDENED_CHARS: Tuple[str, str, str] = ("'", "h", "p")
+    # Master character
+    MASTER_CHAR: str = "m"
+
+
+class Bip32Path:
+    """
+    BIP32 path class.
+    It represents a BIP-0032 path.
+    """
+
+    m_elems: List[Bip32KeyIndex]
+    m_is_absolute: bool
+
+    def __init__(self,
+                 elems: Optional[Sequence[Union[int, Bip32KeyIndex]]] = None,
+                 is_absolute: bool = True) -> None:
+        """
+        Construct class.
+
+        Args:
+            elems (list, optional)      : Path elements (default: empty)
+            is_absolute (bool, optional): True if path is an absolute one, false otherwise (default: True)
+        """
+        try:
+            self.m_elems = ([]
+                            if elems is None
+                            else [Bip32KeyIndex(elem) if isinstance(elem, int) else elem for elem in elems])
+        except ValueError as ex:
+            raise Bip32PathError("The path contains some invalid key indexes") from ex
+
+        self.m_is_absolute = is_absolute
+
+    def AddElem(self,
+                elem: Union[int, Bip32KeyIndex]) -> Bip32Path:
+        """
+        Return a new path object with the specified element added.
+
+        Args:
+            elem (str or Bip32KeyIndex): Path element
+
+        Returns:
+            Bip32Path object: Bip32Path object
+
+        Raises:
+            Bip32PathError: If the path element is not valid
+        """
+        if isinstance(elem, int):
+            elem = Bip32KeyIndex(elem)
+        return Bip32Path(self.m_elems + [elem], self.m_is_absolute)
+
+    def IsAbsolute(self) -> bool:
+        """
+        Get if absolute path.
+
+        Returns:
+            bool: True if absolute path, false otherwise
+        """
+        return self.m_is_absolute
+
+    def Length(self) -> int:
+        """
+        Get the number of elements of the path.
+
+        Returns:
+            int: Number of elements
+        """
+        return len(self.m_elems)
+
+    def ToList(self) -> List[int]:
+        """
+        Get the path as a list of integers.
+
+        Returns:
+            list[int]: Path as a list of integers
+        """
+        return [int(elem) for elem in self.m_elems]
+
+    def ToStr(self) -> str:
+        """
+        Get the path as a string.
+
+        Returns:
+            str: Path as a string
+        """
+        path_str = "" if not self.m_is_absolute else f"{Bip32PathConst.MASTER_CHAR}/"
+        for elem in self.m_elems:
+            if not elem.IsHardened():
+                path_str += f"{str(elem.ToInt())}/"
+            else:
+                path_str += f"{str(Bip32KeyIndex.UnhardenIndex(elem.ToInt()))}'/"
+
+        return path_str[:-1]
+
+    def __str__(self) -> str:
+        """
+        Get the path as a string.
+
+        Returns:
+            str: Path as a string
+        """
+        return self.ToStr()
+
+    def __getitem__(self,
+                    idx: int) -> Bip32KeyIndex:
+        """
+        Get the specified element index.
+
+        Args:
+            idx (int): Element index
+
+        Returns:
+            Bip32KeyIndex object: Bip32KeyIndex object
+        """
+        return self.m_elems[idx]
+
+    def __iter__(self) -> Iterator[Bip32KeyIndex]:
+        """
+        Get the iterator to the current element.
+
+        Returns:
+            Iterator object: Iterator to the current element
+        """
+        yield from self.m_elems
+
+
+class Bip32PathParser:
+    """
+    BIP32 path parser class.
+    It parses a BIP-0032 path and returns a Bip32Path object.
+    """
+
+    @staticmethod
+    def Parse(path: str) -> Bip32Path:
+        """
+        Parse a path and return a Bip32Path object.
+
+        Args:
+            path (str): Path
+
+        Returns:
+            Bip32Path object: Bip32Path object
+
+        Raises:
+            Bip32PathError: If the path is not valid
+        """
+
+        # Remove trailing "/" if any
+        if path.endswith("/"):
+            path = path[:-1]
+
+        # Parse elements
+        return Bip32PathParser.__ParseElements(
+            list(filter(None, path.split("/")))
+        )
+
+    @staticmethod
+    def __ParseElements(path_elems: List[str]) -> Bip32Path:
+        """
+        Parse path elements and return a Bip32Path object.
+
+        Args:
+            path_elems (list[str]): Path elements
+
+        Returns:
+            Bip32Path object: Bip32Path object
+
+        Raises:
+            Bip32PathError: If the path is not valid
+        """
+
+        # Remove the initial "m" character if any
+        if len(path_elems) > 0 and path_elems[0] == Bip32PathConst.MASTER_CHAR:
+            path_elems = path_elems[1:]
+            is_absolute = True
+        else:
+            is_absolute = False
+
+        # Parse elements
+        parsed_elems = list(map(Bip32PathParser.__ParseElem, path_elems))
+        return Bip32Path(parsed_elems, is_absolute)
+
+    @staticmethod
+    def __ParseElem(path_elem: str) -> int:
+        """
+        Parse path element and get the correspondent index.
+
+        Args:
+            path_elem (str): Path element
+
+        Returns:
+            int: Index of the element, None if the element is not a valid index
+
+        Raises:
+            Bip32PathError: If the path is not valid
+        """
+
+        # Strip spaces
+        path_elem = path_elem.strip()
+
+        # Get if hardened
+        is_hardened = path_elem.endswith(Bip32PathConst.HARDENED_CHARS)
+
+        # If hardened, remove the last character from the string
+        if is_hardened:
+            path_elem = path_elem[:-1]
+
+        # The remaining string shall be numeric
+        if not path_elem.isnumeric():
+            raise Bip32PathError(f"Invalid path element ({path_elem})")
+
+        return int(path_elem) if not is_hardened else Bip32KeyIndex.HardenIndex(int(path_elem))