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

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

@@ -0,0 +1,220 @@
+# 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 BitcoinCash bech32 decoding/encoding.
+Reference: https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
+"""
+
+# Imports
+from typing import List, Tuple
+
+from .bech32_base import Bech32BaseUtils, Bech32DecoderBase, Bech32EncoderBase
+from ..utils.misc import BytesUtils, IntegerUtils
+
+
+class BchBech32Const:
+    """Class container for Bitcoin Cash Bech32 constants."""
+
+    # Separator
+    SEPARATOR: str = ":"
+    # Checksum length
+    CHECKSUM_STR_LEN: int = 8
+
+
+class BchBech32Utils:
+    """Class container for Bitcoin Cash utility functions."""
+
+    @staticmethod
+    def PolyMod(values: List[int]) -> int:
+        """
+        Computes the polynomial modulus.
+
+        Args:
+            values (list[int]): List of polynomial coefficients
+
+        Returns:
+            int: Computed modulus
+        """
+
+        # Generator polynomial
+        generator = [
+            (0x01, 0x98f2bc8e61),
+            (0x02, 0x79b76d99e2),
+            (0x04, 0xf33e5fb3c4),
+            (0x08, 0xae2eabe2a8),
+            (0x10, 0x1e4f43e470)
+        ]
+        # Compute modulus
+        chk = 1
+        for value in values:
+            top = chk >> 35
+            chk = ((chk & 0x07ffffffff) << 5) ^ value
+            for i in generator:
+                if top & i[0] != 0:
+                    chk ^= i[1]
+
+        return chk ^ 1
+
+    @staticmethod
+    def HrpExpand(hrp: str) -> List[int]:
+        """
+        Expand the HRP into values for checksum computation.
+
+        Args:
+            hrp (str): HRP
+
+        Returns:
+            list[int]: Expanded HRP values
+        """
+        # [lower 5 bits of each character] + [0]
+        return [ord(x) & 0x1f for x in hrp] + [0]
+
+    @staticmethod
+    def ComputeChecksum(hrp: str,
+                        data: List[int]) -> List[int]:
+        """
+        Compute the checksum from the specified HRP and data.
+
+        Args:
+            hrp (str)       : HRP
+            data (list[int]): Data part
+
+        Returns:
+            list[int]: Computed checksum
+        """
+        values = BchBech32Utils.HrpExpand(hrp) + data
+        polymod = BchBech32Utils.PolyMod(values + [0, 0, 0, 0, 0, 0, 0, 0])
+        return [(polymod >> 5 * (7 - i)) & 0x1f for i in range(BchBech32Const.CHECKSUM_STR_LEN)]
+
+    @staticmethod
+    def VerifyChecksum(hrp: str,
+                       data: List[int]) -> bool:
+        """
+        Verify the checksum from the specified HRP and converted data characters.
+
+        Args:
+            hrp  (str)      : HRP
+            data (list[int]): Data part
+
+        Returns:
+            bool: True if valid, false otherwise
+        """
+        return BchBech32Utils.PolyMod(BchBech32Utils.HrpExpand(hrp) + data) == 0
+
+
+class BchBech32Encoder(Bech32EncoderBase):
+    """
+    Bitcoin Cash Bech32 encoder class.
+    It provides methods for encoding to Bitcoin Cash Bech32 format.
+    """
+
+    @classmethod
+    def Encode(cls,
+               hrp: str,
+               net_ver: bytes,
+               data: bytes) -> str:
+        """
+        Encode to Bitcoin Cash Bech32.
+
+        Args:
+            hrp (str)      : HRP
+            net_ver (bytes): Net version
+            data (bytes)   : Data
+
+        Returns:
+            str: Encoded address
+
+        Raises:
+            ValueError: If the data is not valid
+        """
+        return cls._EncodeBech32(hrp,
+                                 Bech32BaseUtils.ConvertToBase32(net_ver + data),
+                                 BchBech32Const.SEPARATOR)
+
+    @staticmethod
+    def _ComputeChecksum(hrp: str,
+                         data: List[int]) -> List[int]:
+        """
+        Compute the checksum from the specified HRP and data.
+
+        Args:
+            hrp (str)       : HRP
+            data (list[int]): Data part
+
+        Returns:
+            list[int]: Computed checksum
+        """
+        return BchBech32Utils.ComputeChecksum(hrp, data)
+
+
+class BchBech32Decoder(Bech32DecoderBase):
+    """
+    Bitcoin Cash Bech32 decoder class.
+    It provides methods for decoding Bitcoin Cash Bech32 format.
+    """
+
+    @classmethod
+    def Decode(cls,
+               hrp: str,
+               addr: str) -> Tuple[bytes, bytes]:
+        """
+        Decode from Bitcoin Cash Bech32.
+
+        Args:
+            hrp (str) : Human readable part
+            addr (str): Address
+
+        Returns:
+            tuple[bytes, bytes]: Net version (index 0) and data (index 1)
+
+        Raises:
+            ValueError: If the bech32 string is not valid
+            Bech32ChecksumError: If the checksum is not valid
+        """
+
+        # Decode string
+        hrp_got, data = cls._DecodeBech32(addr,
+                                          BchBech32Const.SEPARATOR,
+                                          BchBech32Const.CHECKSUM_STR_LEN)
+
+        # Check HRP
+        if hrp != hrp_got:
+            raise ValueError(f"Invalid format (HRP not valid, expected {hrp}, got {hrp_got})")
+
+        # Convert back from base32
+        conv_data = Bech32BaseUtils.ConvertFromBase32(data)
+
+        return IntegerUtils.ToBytes(conv_data[0]), BytesUtils.FromList(conv_data[1:])
+
+    @staticmethod
+    def _VerifyChecksum(hrp: str,
+                        data: List[int]) -> bool:
+        """
+        Verify the checksum from the specified HRP and converted data characters.
+
+        Args:
+            hrp  (str)      : HRP
+            data (list[int]): Data part
+
+        Returns:
+            bool: True if valid, false otherwise
+        """
+        return BchBech32Utils.VerifyChecksum(hrp, data)

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

@@ -0,0 +1,235 @@
+# 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 bech32/bech32m decoding/encoding.
+
+References:
+    https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+    https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
+    https://github.com/sipa/bech32/blob/master/ref/python/segwit_addr.py
+"""
+
+# Imports
+from enum import Enum, auto, unique
+from typing import Dict, List
+
+from .bech32_base import Bech32BaseUtils, Bech32DecoderBase, Bech32EncoderBase
+from ..utils.misc import BytesUtils
+
+
+@unique
+class Bech32Encodings(Enum):
+    """Enumerative for Bech32 encoding types."""
+
+    BECH32 = auto()
+    BECH32M = auto()
+
+
+class Bech32Const:
+    """Class container for Bech32 constants."""
+
+    # Separator
+    SEPARATOR: str = "1"
+    # Checksum length
+    CHECKSUM_STR_LEN: int = 6
+    # Encoding checksum constants
+    ENCODING_CHECKSUM_CONST: Dict[Bech32Encodings, int] = {
+        Bech32Encodings.BECH32: 1,
+        Bech32Encodings.BECH32M: 0x2bc830a3,
+    }
+
+
+class Bech32Utils:
+    """Class container for Bech32 utility functions."""
+
+    @staticmethod
+    def PolyMod(values: List[int]) -> int:
+        """
+        Computes the polynomial modulus.
+
+        Args:
+            values (list[int]): List of polynomial coefficients
+
+        Returns:
+            int: Computed modulus
+        """
+
+        # Generator polynomial
+        generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+
+        # Compute modulus
+        chk = 1
+        for value in values:
+            top = chk >> 25
+            chk = (chk & 0x1ffffff) << 5 ^ value
+            for i in range(5):
+                chk ^= generator[i] if ((top >> i) & 1) else 0
+        return chk
+
+    @staticmethod
+    def HrpExpand(hrp: str) -> List[int]:
+        """
+        Expand the HRP into values for checksum computation.
+
+        Args:
+            hrp (str): HRP
+
+        Returns:
+            list[int]: Expanded HRP values
+        """
+        # [upper 3 bits of each character] + [0] + [lower 5 bits of each character]
+        return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 0x1f for x in hrp]
+
+    @staticmethod
+    def ComputeChecksum(hrp: str,
+                        data: List[int],
+                        encoding: Bech32Encodings = Bech32Encodings.BECH32) -> List[int]:
+        """
+        Compute the checksum from the specified HRP and data.
+
+        Args:
+            hrp (str)                           : HRP
+            data (list[int])                    : Data part
+            encoding (Bech32Encodings, optional): Encoding type (BECH32 by default)
+
+        Returns:
+            list[int]: Computed checksum
+        """
+        values = Bech32Utils.HrpExpand(hrp) + data
+        polymod = Bech32Utils.PolyMod(values + [0, 0, 0, 0, 0, 0]) ^ Bech32Const.ENCODING_CHECKSUM_CONST[encoding]
+        return [(polymod >> 5 * (5 - i)) & 0x1f for i in range(Bech32Const.CHECKSUM_STR_LEN)]
+
+    @staticmethod
+    def VerifyChecksum(hrp: str,
+                       data: List[int],
+                       encoding: Bech32Encodings = Bech32Encodings.BECH32) -> bool:
+        """
+        Verify the checksum from the specified HRP and converted data characters.
+
+        Args:
+            hrp  (str)                          : HRP
+            data (list[int])                    : Data part
+            encoding (Bech32Encodings, optional): Encoding type (BECH32 by default)
+
+        Returns:
+            bool: True if valid, false otherwise
+        """
+        polymod = Bech32Utils.PolyMod(Bech32Utils.HrpExpand(hrp) + data)
+        return polymod == Bech32Const.ENCODING_CHECKSUM_CONST[encoding]
+
+
+class Bech32Encoder(Bech32EncoderBase):
+    """
+    Bech32 encoder class.
+    It provides methods for encoding to Bech32 format.
+    """
+
+    @classmethod
+    def Encode(cls,
+               hrp: str,
+               data: bytes) -> str:
+        """
+        Encode to Bech32.
+
+        Args:
+            hrp (str)   : HRP
+            data (bytes): Data
+
+        Returns:
+            str: Encoded address
+
+        Raises:
+            ValueError: If the data is not valid
+        """
+        return cls._EncodeBech32(hrp,
+                                 Bech32BaseUtils.ConvertToBase32(data),
+                                 Bech32Const.SEPARATOR)
+
+    @staticmethod
+    def _ComputeChecksum(hrp: str,
+                         data: List[int]) -> List[int]:
+        """
+        Compute the checksum from the specified HRP and data.
+
+        Args:
+            hrp (str)       : HRP
+            data (list[int]): Data part
+
+        Returns:
+            list[int]: Computed checksum
+        """
+
+        # Same as Segwit
+        return Bech32Utils.ComputeChecksum(hrp, data)
+
+
+class Bech32Decoder(Bech32DecoderBase):
+    """
+    Bech32 decoder class.
+    It provides methods for decoding  Bech32 format.
+    """
+
+    @classmethod
+    def Decode(cls,
+               hrp: str,
+               addr: str) -> bytes:
+        """
+        Decode from Bech32.
+
+        Args:
+            hrp (str) : Human readable part
+            addr (str): Address
+
+        Returns:
+            bytes: Decoded address
+
+        Raises:
+            ValueError: If the bech32 string is not valid
+            Bech32ChecksumError: If the checksum is not valid
+        """
+
+        # Decode string
+        hrp_got, data = cls._DecodeBech32(addr,
+                                          Bech32Const.SEPARATOR,
+                                          Bech32Const.CHECKSUM_STR_LEN)
+        # Check HRP
+        if hrp != hrp_got:
+            raise ValueError(f"Invalid format (HRP not valid, expected {hrp}, got {hrp_got})")
+
+        # Convert back from base32
+        return BytesUtils.FromList(
+            Bech32BaseUtils.ConvertFromBase32(data)
+        )
+
+    @staticmethod
+    def _VerifyChecksum(hrp: str,
+                        data: List[int]) -> bool:
+        """
+        Verify the checksum from the specified HRP and converted data characters.
+
+        Args:
+            hrp  (str)      : HRP
+            data (list[int]): Data part
+
+        Returns:
+            bool: True if valid, false otherwise
+        """
+        return Bech32Utils.VerifyChecksum(hrp, data)

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

@@ -0,0 +1,246 @@
+# 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 base bech32 decoding/encoding."""
+
+# Imports
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple, Union
+
+from .bech32_ex import Bech32ChecksumError
+from ..utils.misc import AlgoUtils
+
+
+class Bech32BaseConst:
+    """Class container for Bech32 constants."""
+
+    # Character set
+    CHARSET: str = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+
+
+class Bech32BaseUtils:
+    """Class container for Bech32 utility functions."""
+
+    @staticmethod
+    def ConvertToBase32(data: Union[List[int], bytes]) -> List[int]:
+        """
+        Convert data to base32.
+
+        Args:
+            data (list[int] or bytes): Data to be converted
+
+        Returns:
+            list[int]: Converted data
+
+        Raises:
+            ValueError: If the string is not valid
+        """
+
+        # Convert to base32
+        conv_data = Bech32BaseUtils.ConvertBits(data, 8, 5)
+        if conv_data is None:
+            raise ValueError("Invalid data, cannot perform conversion to base32")
+
+        return conv_data
+
+    @staticmethod
+    def ConvertFromBase32(data: Union[List[int], bytes]) -> List[int]:
+        """
+        Convert data from base32.
+
+        Args:
+            data (list[int] or bytes): Data to be converted
+
+        Returns:
+            list[int]: Converted data
+
+        Raises:
+            ValueError: If the string is not valid
+        """
+
+        # Convert from base32
+        conv_data = Bech32BaseUtils.ConvertBits(data, 5, 8, False)
+        if conv_data is None:
+            raise ValueError("Invalid data, cannot perform conversion from base32")
+
+        return conv_data
+
+    @staticmethod
+    def ConvertBits(data: Union[bytes, List[int]],
+                    from_bits: int,
+                    to_bits: int,
+                    pad: bool = True) -> Optional[List[int]]:
+        """
+        Perform bit conversion.
+        The function takes the input data (list of integers or byte sequence) and convert every value from
+        the specified number of bits to the specified one.
+        It returns a list of integer where every number is less than 2^to_bits.
+
+        Args:
+            data (list[int] or bytes): Data to be converted
+            from_bits (int)          : Number of bits to start from
+            to_bits (int)            : Number of bits to end with
+            pad (bool, optional)     : True if data must be padded with zeros, false otherwise
+
+        Returns:
+            list[int]: List of converted values, None in case of errors
+        """
+        max_out_val = (1 << to_bits) - 1
+        max_acc = (1 << (from_bits + to_bits - 1)) - 1
+
+        acc = 0
+        bits = 0
+        ret = []
+
+        for value in data:
+            # Value shall not be less than zero or greater than 2^from_bits
+            if value < 0 or (value >> from_bits):
+                return None
+            # Continue accumulating until greater than to_bits
+            acc = ((acc << from_bits) | value) & max_acc
+            bits += from_bits
+            while bits >= to_bits:
+                bits -= to_bits
+                ret.append((acc >> bits) & max_out_val)
+        if pad:
+            if bits:
+                # Pad the value with zeros to reach to_bits
+                ret.append((acc << (to_bits - bits)) & max_out_val)
+        elif bits >= from_bits or ((acc << (to_bits - bits)) & max_out_val):
+            return None
+
+        return ret
+
+
+class Bech32EncoderBase(ABC):
+    """
+    Bech32 encoder base class.
+    It provides methods for encoding to Bech32 format.
+    """
+
+    @classmethod
+    def _EncodeBech32(cls,
+                      hrp: str,
+                      data: List[int],
+                      sep: str) -> str:
+        """
+        Encode a Bech32 string from the specified HRP and data.
+
+        Args:
+            hrp (str)       : HRP
+            data (list[int]): Data part
+            sep (str)       : Bech32 separator
+
+        Returns:
+            str: Encoded data
+        """
+
+        # Add checksum to data
+        data += cls._ComputeChecksum(hrp, data)
+        # Encode to alphabet
+        return hrp + sep + "".join([Bech32BaseConst.CHARSET[d] for d in data])
+
+    @staticmethod
+    @abstractmethod
+    def _ComputeChecksum(hrp: str,
+                         data: List[int]) -> List[int]:
+        """
+        Compute the checksum from the specified HRP and data.
+
+        Args:
+            hrp (str)       : HRP
+            data (list[int]): Data part
+
+        Returns:
+            list[int]: Computed checksum
+        """
+
+
+class Bech32DecoderBase(ABC):
+    """
+    Bech32 decoder base class.
+    It provides methods for decoding Bech32 format.
+    """
+
+    @classmethod
+    def _DecodeBech32(cls,
+                      bech_str: str,
+                      sep: str,
+                      checksum_len: int) -> Tuple[str, List[int]]:
+        """
+        Decode and validate a Bech32 string, determining its HRP and data.
+
+        Args:
+            bech_str (str)    : Bech32 string
+            sep (str)         : Bech32 separator
+            checksum_len (int): Checksum length
+
+        Returns:
+            tuple[str, list[int]]: HRP (index 0) and data part (index 1)
+
+        Raises:
+            ValueError: If the string is not valid
+            Bech32ChecksumError: If the checksum is not valid
+        """
+
+        # Check string length and case
+        if AlgoUtils.IsStringMixed(bech_str):
+            raise ValueError("Invalid bech32 format (string is mixed case)")
+
+        # Lower string
+        bech_str = bech_str.lower()
+
+        # Find separator and check its position
+        sep_pos = bech_str.rfind(sep)
+        if sep_pos == -1:
+            raise ValueError("Invalid bech32 format (no separator found)")
+
+        # Get HRP and check it
+        hrp = bech_str[:sep_pos]
+        if len(hrp) == 0 or any(ord(x) < 33 or ord(x) > 126 for x in hrp):
+            raise ValueError(f"Invalid bech32 format (HRP not valid: {hrp})")
+
+        # Get data and check it
+        data_part = bech_str[sep_pos + 1:]
+        if (len(data_part) < (checksum_len + 1)
+                or not all(x in Bech32BaseConst.CHARSET for x in data_part)):
+            raise ValueError("Invalid bech32 format (data part not valid)")
+
+        # Convert back from alphabet and verify checksum
+        int_data = [Bech32BaseConst.CHARSET.find(x) for x in data_part]
+        if not cls._VerifyChecksum(hrp, int_data):
+            raise Bech32ChecksumError("Invalid bech32 checksum")
+
+        return hrp, int_data[:-checksum_len]
+
+    @staticmethod
+    @abstractmethod
+    def _VerifyChecksum(hrp: str,
+                        data: List[int]) -> bool:
+        """
+        Verify the checksum from the specified HRP and converted data characters.
+
+        Args:
+            hrp  (str)      : HRP
+            data (list[int]): Data part
+
+        Returns:
+            bool: True if valid, false otherwise
+        """