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

coinex/ccxt/static_dependencies/bip/utils/crypto/ripemd.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2022 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 RIPEMD algorithm."""
+
+# Imports
+from typing import Union
+
+from Crypto.Hash import RIPEMD160
+
+from ..misc import AlgoUtils
+
+
+class Ripemd160:
+    """
+    RIPEMD160 class.
+    It computes digests using RIPEMD160 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        return RIPEMD160.new(AlgoUtils.Encode(data)).digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return RIPEMD160.digest_size

coinex/ccxt/static_dependencies/bip/utils/crypto/scrypt.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2022 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 Scrypt algorithm."""
+
+# Imports
+from typing import Union
+
+from Crypto.Protocol.KDF import scrypt
+
+from ..misc import AlgoUtils
+
+
+class Scrypt:
+    """
+    Scrypt class.
+    It derives key using Scrypt algorithm.
+    """
+
+    @staticmethod
+    def DeriveKey(password: Union[bytes, str],  # pylint: disable=too-many-arguments
+                  salt: Union[bytes, str],
+                  key_len: int,
+                  n: int,
+                  r: int,
+                  p: int) -> bytes:
+        """
+        Derive a key.
+
+        Args:
+            password (str or bytes): Password
+            salt (str or bytes)    : Salt
+            key_len (int)          : Length of the derived key
+            n (int)                : CPU/Memory cost parameter
+            r (int)                : Block size parameter
+            p (int)                : Parallelization parameter
+
+        Returns:
+            bytes: Computed result
+        """
+
+        # Type for password and salt should be Union[bytes, str] in pycryptodome, but it's only str
+        # So, we ignore the mypy warning
+        return scrypt(AlgoUtils.Encode(password),   # type: ignore [arg-type, return-value]
+                      AlgoUtils.Encode(salt),       # type: ignore [arg-type]
+                      key_len=key_len,
+                      N=n,
+                      r=r,
+                      p=p)

coinex/ccxt/static_dependencies/bip/utils/crypto/sha2.py

@@ -0,0 +1,182 @@
+# Copyright (c) 2022 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 SHA-2 algorithms."""
+
+# Imports
+import hashlib
+from typing import Any, Union
+
+from Crypto.Hash import SHA512
+
+from ..misc import AlgoUtils
+
+
+HASHLIB_USE_SHA512_256: bool = "sha512_256" in hashlib.algorithms_available
+
+
+class Sha256:
+    """
+    SHA256 class.
+    It computes digests using SHA256 algorithm.
+    """
+
+    handle: Any
+
+    def __init__(self) -> None:
+        """Construct class."""
+        self.handle = hashlib.sha256()
+
+    def Update(self,
+               data_bytes: bytes) -> None:
+        """
+        Update digest.
+
+        Args:
+            data_bytes (bytes): Data bytes
+        """
+        self.handle.update(data_bytes)
+
+    def Digest(self) -> bytes:
+        """
+        Get the computed digest.
+
+        Returns:
+            bytes: Computed digest
+        """
+        return self.handle.digest()
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        return hashlib.sha256(AlgoUtils.Encode(data)).digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return hashlib.sha256().digest_size
+
+
+class DoubleSha256:
+    """
+    Double SHA256 class.
+    It computes digests using SHA256 algorithm twice.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        return Sha256.QuickDigest(Sha256.QuickDigest(data))
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return Sha256.DigestSize()
+
+
+class Sha512:
+    """
+    SHA512 class.
+    It computes digests using SHA512 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        return hashlib.sha512(AlgoUtils.Encode(data)).digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return hashlib.sha512().digest_size
+
+
+class Sha512_256:   # noqa: N801
+    """
+    SHA512/256 class.
+    It computes digests using SHA512/256 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        if HASHLIB_USE_SHA512_256:
+            return hashlib.new("sha512_256", AlgoUtils.Encode(data)).digest()
+        # Use Cryptodome if not implemented in hashlib
+        return SHA512.new(AlgoUtils.Encode(data), truncate="256").digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return (hashlib.new("sha512_256").digest_size
+                if HASHLIB_USE_SHA512_256
+                else SHA512.new(truncate="256").digest_size)

coinex/ccxt/static_dependencies/bip/utils/crypto/sha3.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2022 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 SHA-3 algorithms."""
+
+# Imports
+import hashlib
+from typing import Union
+
+from Crypto.Hash import SHA3_256, keccak
+
+from ..misc import AlgoUtils
+
+
+HASHLIB_USE_SHA3_256: bool = "sha3_256" in hashlib.algorithms_available
+
+
+class Kekkak256:
+    """
+    Kekkak-256 class.
+    It computes digests using Kekkak-256 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        return keccak.new(data=AlgoUtils.Encode(data), digest_bits=256).digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return (hashlib.new("sha3_256").digest_size
+                if HASHLIB_USE_SHA3_256
+                else keccak.new(digest_bits=256).digest_size)
+
+
+class Sha3_256:     # noqa: N801
+    """
+    SHA3-256 class.
+    It computes digests using SHA3-256 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        if HASHLIB_USE_SHA3_256:
+            return hashlib.new("sha3_256", AlgoUtils.Encode(data)).digest()
+        # Use Cryptodome if not implemented in hashlib
+        return SHA3_256.new(AlgoUtils.Encode(data)).digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return (hashlib.new("sha3_256").digest_size
+                if HASHLIB_USE_SHA3_256
+                else SHA3_256.digest_size)

coinex/ccxt/static_dependencies/bip/utils/misc/__init__.py

@@ -0,0 +1,7 @@
+from .algo import AlgoUtils
+from .base32 import Base32Decoder, Base32Encoder
+from .bit import BitUtils
+from .bytes import BytesUtils
+from .data_bytes import DataBytes
+from .integer import IntegerUtils
+from .string import StringUtils

coinex/ccxt/static_dependencies/bip/utils/misc/algo.py

@@ -0,0 +1,108 @@
+# 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 some algorithm utility functions."""
+
+# Imports
+from bisect import bisect_left
+from typing import Any, List, Union
+
+
+class AlgoUtils:
+    """Class container for algorithm utility functions."""
+
+    @staticmethod
+    def BinarySearch(arr: List,
+                     elem: Any) -> int:
+        """
+        Binary search algorithm simply implemented by using the bisect library.
+
+        Args:
+            arr (list): list of elements
+            elem (any): element to be searched
+
+        Returns:
+            int: First index of the element, -1 if not found
+        """
+
+        invalid_idx = -1
+
+        i = bisect_left(arr, elem)
+        if i != len(arr) and arr[i] == elem:
+            return i
+
+        return invalid_idx
+
+    @staticmethod
+    def Decode(data: Union[bytes, str],
+               encoding: str = "utf-8") -> str:
+        """
+        Decode from bytes.
+
+        Args:
+            data (str or bytes): Data
+            encoding (str)     : Encoding type
+
+        Returns:
+            str: String encoded to bytes
+
+        Raises:
+            TypeError: If the data is neither string nor bytes
+        """
+        if isinstance(data, str):
+            return data
+        if isinstance(data, bytes):
+            return data.decode(encoding)
+        raise TypeError("Invalid data type")
+
+    @staticmethod
+    def Encode(data: Union[bytes, str],
+               encoding: str = "utf-8") -> bytes:
+        """
+        Encode to bytes.
+
+        Args:
+            data (str or bytes): Data
+            encoding (str)     : Encoding type
+
+        Returns:
+            bytes: String encoded to bytes
+
+        Raises:
+            TypeError: If the data is neither string nor bytes
+        """
+        if isinstance(data, str):
+            return data.encode(encoding)
+        if isinstance(data, bytes):
+            return data
+        raise TypeError("Invalid data type")
+
+    @staticmethod
+    def IsStringMixed(data_str: str) -> bool:
+        """
+        Get if the specified string is in mixed case.
+
+        Args:
+            data_str (str): string
+
+        Returns:
+            bool: True if mixed case, false otherwise
+        """
+        return any(c.islower() for c in data_str) and any(c.isupper() for c in data_str)

coinex/ccxt/static_dependencies/bip/utils/misc/base32.py

@@ -0,0 +1,151 @@
+# 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 Base32."""
+
+# Imports
+import base64
+import binascii
+from typing import Optional, Union
+
+from .algo import AlgoUtils
+
+
+class Base32Const:
+    """Class container for Base32 constants."""
+
+    # Alphabet
+    ALPHABET: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+    # Padding character
+    PADDING_CHAR: str = "="
+
+
+class _Base32Utils:
+    """
+    Base32 utility class.
+    It provides some helper methods for decoding/encoding Base32 format.
+    """
+
+    @staticmethod
+    def AddPadding(data: str) -> str:
+        """
+        Add padding to an encoded Base32 string.
+        Used if the string was encoded with Base32Encoder.EncodeNoPadding
+
+        Args:
+            data (str): Data
+
+        Returns:
+            str: Padded string
+        """
+        last_block_width = len(data) % 8
+        if last_block_width != 0:
+            data += (8 - last_block_width) * Base32Const.PADDING_CHAR
+        return data
+
+    @staticmethod
+    def TranslateAlphabet(data: str,
+                          from_alphabet: str,
+                          to_alphabet: str) -> str:
+        """
+        Translate the standard Base32 alphabet to a custom one.
+
+        Args:
+            data (str)         : Data
+            from_alphabet (str): Starting alphabet string
+            to_alphabet (str)  : Final alphabet string
+
+        Returns:
+            str: String with translated alphabet
+        """
+        return data.translate(str.maketrans(from_alphabet, to_alphabet))
+
+
+class Base32Decoder:
+    """
+    Base32 decoder class.
+    It provides methods for decoding to Base32 format.
+    """
+
+    @staticmethod
+    def Decode(data: str,
+               custom_alphabet: Optional[str] = None) -> bytes:
+        """
+        Decode from Base32.
+
+        Args:
+            data (str)                     : Data
+            custom_alphabet (str, optional): Custom alphabet string
+
+        Returns:
+            bytes: Decoded bytes
+
+        Raises:
+            ValueError: If the Base32 string is not valid
+        """
+        try:
+            data_dec = _Base32Utils.AddPadding(data)
+            if custom_alphabet is not None:
+                data_dec = _Base32Utils.TranslateAlphabet(data_dec, custom_alphabet, Base32Const.ALPHABET)
+
+            return base64.b32decode(data_dec)
+        except binascii.Error as ex:
+            raise ValueError("Invalid Base32 string") from ex
+
+
+class Base32Encoder:
+    """
+    Base32 encoder class.
+    It provides methods for encoding to Base32 format.
+    """
+
+    @staticmethod
+    def Encode(data: Union[bytes, str],
+               custom_alphabet: Optional[str] = None) -> str:
+        """
+        Encode to Base32.
+
+        Args:
+            data (str or bytes)            : Data
+            custom_alphabet (str, optional): Custom alphabet string
+
+        Returns:
+            str: Encoded string
+        """
+        b32_enc = AlgoUtils.Decode(base64.b32encode(AlgoUtils.Encode(data)))
+        if custom_alphabet is not None:
+            b32_enc = _Base32Utils.TranslateAlphabet(b32_enc, Base32Const.ALPHABET, custom_alphabet)
+
+        return b32_enc
+
+    @staticmethod
+    def EncodeNoPadding(data: Union[bytes, str],
+                        custom_alphabet: Optional[str] = None) -> str:
+        """
+        Encode to Base32 by removing the final padding.
+
+        Args:
+            data (str or bytes)            : Data
+            custom_alphabet (str, optional): Custom alphabet string
+
+        Returns:
+            str: Encoded string
+        """
+        return Base32Encoder.Encode(data, custom_alphabet).rstrip(Base32Const.PADDING_CHAR)