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

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

@@ -0,0 +1,48 @@
+# 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 interface for address encoding classes."""
+
+# Imports
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class IAddrDecoder(ABC):
+    """Address decoder interface."""
+
+    @staticmethod
+    @abstractmethod
+    def DecodeAddr(addr: str,
+                   **kwargs: Any) -> bytes:
+        """
+        Decode an address to bytes.
+        Depending on the coin, the result can be a public key or a public key hash bytes.
+
+        Args:
+            addr (str): Address string
+            **kwargs  : Arbitrary arguments depending on the address type
+
+        Returns:
+            bytes: Public key bytes or public key hash
+
+        Raises:
+            ValueError: If the address encoding is not valid
+        """

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

@@ -0,0 +1,50 @@
+# 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 interface for address encoding classes."""
+
+# Imports
+from abc import ABC, abstractmethod
+from typing import Any, Union
+
+from ..ecc import IPublicKey
+
+
+class IAddrEncoder(ABC):
+    """Address encoder interface."""
+
+    @staticmethod
+    @abstractmethod
+    def EncodeKey(pub_key: Union[bytes, IPublicKey],
+                  **kwargs: Any) -> str:
+        """
+        Encode public key to address.
+
+        Args:
+            pub_key (bytes or IPublicKey): Public key bytes or object
+            **kwargs                     : Arbitrary arguments depending on the address type
+
+        Returns:
+            str: Address string
+
+        Raised:
+            ValueError: If the public key is not valid
+            TypeError: If the public key is not of the correct type (it depends on the address type)
+        """

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

@@ -0,0 +1,3 @@
+from .base58 import Base58Alphabets, Base58Decoder, Base58Encoder
+from .base58_ex import Base58ChecksumError
+from .base58_xmr import Base58XmrDecoder, Base58XmrEncoder

coinex/ccxt/static_dependencies/bip/base58/base58.py

@@ -0,0 +1,207 @@
+# 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 base58 decoding/encoding."""
+
+# Imports
+from enum import Enum, auto, unique
+from typing import Dict
+
+from .base58_ex import Base58ChecksumError
+from ..utils.crypto import DoubleSha256
+from ..utils.misc import BytesUtils
+
+
+@unique
+class Base58Alphabets(Enum):
+    """Enumerative for Base58 alphabet."""
+
+    BITCOIN = auto()
+    RIPPLE = auto()
+
+
+class Base58Const:
+    """Class container for Base58 constants."""
+
+    # Base58 radix
+    RADIX: int = 58
+    # Checksum length in bytes
+    CHECKSUM_BYTE_LEN: int = 4
+    # Alphabets
+    ALPHABETS: Dict[Base58Alphabets, str] = {
+        Base58Alphabets.BITCOIN: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+        Base58Alphabets.RIPPLE: "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz",
+    }
+
+
+class Base58Utils:
+    """Class container for Base58 utility functions."""
+
+    @staticmethod
+    def ComputeChecksum(data_bytes: bytes) -> bytes:
+        """
+        Compute Base58 checksum.
+
+        Args:
+            data_bytes (bytes): Data bytes
+
+        Returns:
+            bytes: Computed checksum
+        """
+        return DoubleSha256.QuickDigest(data_bytes)[:Base58Const.CHECKSUM_BYTE_LEN]
+
+
+class Base58Encoder:
+    """Base58 encoder class. It provides methods for encoding and checksum encoding to Base58 format."""
+
+    @staticmethod
+    def Encode(data_bytes: bytes,
+               alph_idx: Base58Alphabets = Base58Alphabets.BITCOIN) -> str:
+        """
+        Encode bytes into a Base58 string.
+
+        Args:
+            data_bytes (bytes)                  : Data bytes
+            alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
+
+        Returns:
+            str: Encoded string
+
+        Raises:
+            TypeError: If alphabet index is not a Base58Alphabets enumerative
+        """
+        if not isinstance(alph_idx, Base58Alphabets):
+            raise TypeError("Alphabet index is not an enumerative of Base58Alphabets")
+
+        enc = ""
+
+        # Get alphabet
+        alphabet = Base58Const.ALPHABETS[alph_idx]
+
+        # Convert bytes to integer
+        val = BytesUtils.ToInteger(data_bytes)
+
+        # Algorithm implementation
+        while val > 0:
+            val, mod = divmod(val, Base58Const.RADIX)
+            enc = alphabet[mod] + enc
+
+        # Get number of leading zeros
+        n = len(data_bytes) - len(data_bytes.lstrip(b"\x00"))
+        # Add padding
+        return (alphabet[0] * n) + enc
+
+    @staticmethod
+    def CheckEncode(data_bytes: bytes,
+                    alph_idx: Base58Alphabets = Base58Alphabets.BITCOIN) -> str:
+        """
+        Encode bytes into Base58 string with checksum.
+
+        Args:
+            data_bytes (bytes)                  : Data bytes
+            alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
+
+        Returns:
+            str: Encoded string with checksum
+
+        Raises:
+            TypeError: If alphabet index is not a Base58Alphabets enumerative
+        """
+
+        # Append checksum and encode all together
+        return Base58Encoder.Encode(data_bytes + Base58Utils.ComputeChecksum(data_bytes), alph_idx)
+
+
+class Base58Decoder:
+    """Base58 decoder class. It provides methods for decoding and checksum decoding Base58 format."""
+
+    @staticmethod
+    def Decode(data_str: str,
+               alph_idx: Base58Alphabets = Base58Alphabets.BITCOIN) -> bytes:
+        """
+        Decode bytes from a Base58 string.
+
+        Args:
+            data_str (str)                      : Data string
+            alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
+
+        Returns:
+            bytes: Decoded bytes
+
+        Raises:
+            TypeError: If alphabet index is not a Base58Alphabets enumerative
+        """
+        if not isinstance(alph_idx, Base58Alphabets):
+            raise TypeError("Alphabet index is not an enumerative of Base58Alphabets")
+
+        # Get alphabet
+        alphabet = Base58Const.ALPHABETS[alph_idx]
+
+        # Convert string to integer
+        val = 0
+        for i, c in enumerate(data_str[::-1]):
+            val += alphabet.index(c) * (Base58Const.RADIX ** i)
+
+        dec = bytearray()
+        while val > 0:
+            val, mod = divmod(val, 2**8)
+            dec.append(mod)
+
+        # Get padding length
+        pad_len = len(data_str) - len(data_str.lstrip(alphabet[0]))
+        # Add padding
+        return (b"\x00" * pad_len) + bytes(dec[::-1])
+
+    @staticmethod
+    def CheckDecode(data_str: str,
+                    alph_idx: Base58Alphabets = Base58Alphabets.BITCOIN) -> bytes:
+        """
+        Decode bytes from a Base58 string with checksum.
+
+        Args:
+            data_str (str)                      : Data string
+            alph_idx (Base58Alphabets, optional): Alphabet index, Bitcoin by default
+
+        Returns:
+            bytes: Decoded bytes (checksum removed)
+
+        Raises:
+            ValueError: If the string is not a valid Base58 format
+            TypeError: If alphabet index is not a Base58Alphabets enumerative
+            Base58ChecksumError: If checksum is not valid
+        """
+
+        # Decode string
+        dec_bytes = Base58Decoder.Decode(data_str, alph_idx)
+        # Get data and checksum bytes
+        data_bytes = dec_bytes[:-Base58Const.CHECKSUM_BYTE_LEN]
+        checksum_bytes = dec_bytes[-Base58Const.CHECKSUM_BYTE_LEN:]
+
+        # Compute checksum
+        checksum_bytes_got = Base58Utils.ComputeChecksum(data_bytes)
+
+        # Verify checksum
+        if checksum_bytes != checksum_bytes_got:
+            raise Base58ChecksumError(
+                f"Invalid checksum (expected {BytesUtils.ToHexString(checksum_bytes_got)}, "
+                f"got {BytesUtils.ToHexString(checksum_bytes)})"
+            )
+
+        return data_bytes

coinex/ccxt/static_dependencies/bip/base58/base58_ex.py

@@ -0,0 +1,25 @@
+# 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 base58 exceptions."""
+
+
+class Base58ChecksumError(Exception):
+    """Exception in case of checksum error."""

coinex/ccxt/static_dependencies/bip/base58/base58_xmr.py

@@ -0,0 +1,155 @@
+# 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 base58-monero decoding/encoding."""
+
+# Imports
+from typing import List
+
+from .base58 import Base58Alphabets, Base58Const, Base58Decoder, Base58Encoder
+
+
+class Base58XmrConst:
+    """Class container for Base58 Monero constants."""
+
+    # Alphabet
+    ALPHABET: str = Base58Const.ALPHABETS[Base58Alphabets.BITCOIN]
+
+    # Block decoded maximum length in bytes
+    BLOCK_DEC_MAX_BYTE_LEN: int = 8
+
+    # Block encoded maximum length in bytes
+    BLOCK_ENC_MAX_BYTE_LEN: int = 11
+    # Block encoded lengths in bytes
+    BLOCK_ENC_BYTE_LENS: List[int] = [0, 2, 3, 5, 6, 7, 9, 10, 11]
+
+
+class Base58XmrEncoder:
+    """
+    Base58 Monero encoder class.
+    It provides methods for encoding to Base58 format with Monero variation (encoding by blocks of 8-byte).
+    """
+
+    @staticmethod
+    def Encode(data_bytes: bytes) -> str:
+        """
+        Encode bytes into a Base58 string with Monero variation.
+
+        Args:
+            data_bytes (bytes): Data bytes
+
+        Returns:
+            str: Encoded string
+        """
+        enc = ""
+
+        # Get lengths
+        data_len = len(data_bytes)
+        block_dec_len = Base58XmrConst.BLOCK_DEC_MAX_BYTE_LEN
+
+        # Compute total block count and last block length
+        tot_block_cnt, last_block_enc_len = divmod(data_len, block_dec_len)
+
+        # Encode each single block and pad
+        for i in range(tot_block_cnt):
+            block_enc = Base58Encoder.Encode(data_bytes[i * block_dec_len:(i + 1) * block_dec_len])
+            enc += Base58XmrEncoder.__Pad(block_enc, Base58XmrConst.BLOCK_ENC_MAX_BYTE_LEN)
+
+        # Encode last block and pad
+        if last_block_enc_len > 0:
+            block_enc = Base58Encoder.Encode(
+                data_bytes[tot_block_cnt * block_dec_len:(tot_block_cnt * block_dec_len) + last_block_enc_len])
+            enc += Base58XmrEncoder.__Pad(block_enc, Base58XmrConst.BLOCK_ENC_BYTE_LENS[last_block_enc_len])
+
+        return enc
+
+    @staticmethod
+    def __Pad(enc_str: str,
+              pad_len: int) -> str:
+        """
+        Pad the encoded string to the specified length.
+
+        Args:
+            enc_str (str): Encoded string
+            pad_len (int): Pad length
+
+        Returns:
+            str: Padded string
+        """
+        return enc_str.rjust(pad_len, Base58XmrConst.ALPHABET[0])
+
+
+class Base58XmrDecoder:
+    """
+    Base58 Monero decoder class.
+    It provides methods for decoding Base58 format with Monero variation (encoding by blocks of 8-byte).
+    """
+
+    @staticmethod
+    def Decode(data_str: str) -> bytes:
+        """
+        Decode bytes from a Base58 string with Monero variation.
+
+        Args:
+            data_str (str): Data string
+
+        Returns:
+            bytes: Decoded bytes
+        """
+        dec = b""
+
+        # Get lengths
+        data_len = len(data_str)
+        block_dec_len = Base58XmrConst.BLOCK_DEC_MAX_BYTE_LEN
+        block_enc_len = Base58XmrConst.BLOCK_ENC_MAX_BYTE_LEN
+
+        # Compute block count and last block length
+        tot_block_cnt, last_block_enc_len = divmod(data_len, block_enc_len)
+
+        # Get last block decoded length
+        last_block_dec_len = Base58XmrConst.BLOCK_ENC_BYTE_LENS.index(last_block_enc_len)
+
+        # Decode each single block and unpad
+        for i in range(tot_block_cnt):
+            block_dec = Base58Decoder.Decode(data_str[(i * block_enc_len):((i + 1) * block_enc_len)])
+            dec += Base58XmrDecoder.__UnPad(block_dec, block_dec_len)
+
+        # Decode last block and unpad
+        if last_block_enc_len > 0:
+            block_dec = Base58Decoder.Decode(
+                data_str[(tot_block_cnt * block_enc_len):((tot_block_cnt * block_enc_len) + last_block_enc_len)])
+            dec += Base58XmrDecoder.__UnPad(block_dec, last_block_dec_len)
+
+        return dec
+
+    @staticmethod
+    def __UnPad(dec_bytes: bytes,
+                unpad_len: int) -> bytes:
+        """
+        Unpad the decoded string to the specified length.
+
+        Args:
+            dec_bytes (bytes): Decoded bytes
+            unpad_len (int): Unpad length
+
+        Returns:
+            bytes: Unpadded string
+        """
+        return dec_bytes[len(dec_bytes) - unpad_len:len(dec_bytes)]

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

@@ -0,0 +1,4 @@
+from .bch_bech32 import BchBech32Decoder, BchBech32Encoder
+from .bech32 import Bech32Decoder, Bech32Encoder
+from .bech32_ex import Bech32ChecksumError
+from .segwit_bech32 import SegwitBech32Decoder, SegwitBech32Encoder