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

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

@@ -0,0 +1,72 @@
+# 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 BIP32 utility functions."""
+
+# Imports
+from .bip32_key_data import Bip32KeyIndex
+
+
+class Bip32Utils:
+    """
+    BIP32 utility class.
+    It contains some helper methods for Bip32 indexes.
+
+    Deprecated: only for compatibility, methods were moved to Bip32KeyIndex.
+    """
+
+    @staticmethod
+    def HardenIndex(index: int) -> int:
+        """
+        Harden the specified index and return it.
+
+        Args:
+            index (int): Index
+
+        Returns:
+            int: Hardened index
+        """
+        return Bip32KeyIndex.HardenIndex(index)
+
+    @staticmethod
+    def UnhardenIndex(index: int) -> int:
+        """
+        Unharden the specified index and return it.
+
+        Args:
+            index (int): Index
+
+        Returns:
+            int: Unhardened index
+        """
+        return Bip32KeyIndex.UnhardenIndex(index)
+
+    @staticmethod
+    def IsHardenedIndex(index: int) -> bool:
+        """
+        Get if the specified index is hardened.
+
+        Args:
+            index (int): Index
+
+        Returns:
+            bool: True if hardened, false otherwise
+        """
+        return Bip32KeyIndex.IsHardenedIndex(index)

coinex/ccxt/static_dependencies/bip/bip32/kholaw/__init__.py

@@ -0,0 +1,4 @@
+# from .kholaw.bip32_kholaw_ed25519 import Bip32Ed25519Kholaw, Bip32KholawEd25519
+# from .kholaw.bip32_kholaw_ed25519_key_derivator import Bip32KholawEd25519KeyDerivator
+# from .kholaw.bip32_kholaw_key_derivator_base import Bip32KholawEd25519KeyDerivatorBase
+# from .kholaw.bip32_kholaw_mst_key_generator import Bip32KholawEd25519MstKeyGenerator

coinex/ccxt/static_dependencies/bip/bip32/kholaw/bip32_kholaw_ed25519.py

@@ -0,0 +1,82 @@
+# 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 keys derivation based on ed25519 curve as defined by BIP32 Khovratovich/Law."""
+
+# Imports
+from typing import Type
+
+from .base import Bip32Base, IBip32KeyDerivator, IBip32MstKeyGenerator
+from .bip32_const import Bip32Const
+from .bip32_key_net_ver import Bip32KeyNetVersions
+from .kholaw.bip32_kholaw_ed25519_key_derivator import Bip32KholawEd25519KeyDerivator
+from .kholaw.bip32_kholaw_mst_key_generator import Bip32KholawEd25519MstKeyGenerator
+from bip_utils.ecc import EllipticCurveTypes
+
+
+class Bip32KholawEd25519(Bip32Base):
+    """
+    BIP32 Khovratovich/Law ed25519 class.
+    It allows master keys generation and keys derivation using ed25519 curve.
+    """
+
+    @staticmethod
+    def CurveType() -> EllipticCurveTypes:
+        """
+        Return the elliptic curve type.
+
+        Returns:
+            EllipticCurveTypes: Curve type
+        """
+        return EllipticCurveTypes.ED25519_KHOLAW
+
+    @staticmethod
+    def _DefaultKeyNetVersion() -> Bip32KeyNetVersions:
+        """
+        Return the default key net version.
+
+        Returns:
+            Bip32KeyNetVersions object: Bip32KeyNetVersions object
+        """
+        return Bip32Const.KHOLAW_KEY_NET_VERSIONS
+
+    @staticmethod
+    def _KeyDerivator() -> Type[IBip32KeyDerivator]:
+        """
+        Return the key derivator class.
+
+        Returns:
+            IBip32KeyDerivator class: Key derivator class
+        """
+        return Bip32KholawEd25519KeyDerivator
+
+    @staticmethod
+    def _MasterKeyGenerator() -> Type[IBip32MstKeyGenerator]:
+        """
+        Return the master key generator class.
+
+        Returns:
+            IBip32MstKeyGenerator class: Master key generator class
+        """
+        return Bip32KholawEd25519MstKeyGenerator
+
+
+# Deprecated: only for compatibility
+Bip32Ed25519Kholaw = Bip32KholawEd25519

coinex/ccxt/static_dependencies/bip/bip32/kholaw/bip32_kholaw_ed25519_key_derivator.py

@@ -0,0 +1,118 @@
+# 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 BIP32 Khovratovich/Law keys derivation.
+Reference: https://github.com/LedgerHQ/orakolo/blob/master/papers/Ed25519_BIP%20Final.pdf
+"""
+
+# Imports
+from .bip32_ex import Bip32KeyError
+from .bip32_key_data import Bip32KeyIndex
+from .bip32_keys import Bip32PublicKey
+from .kholaw.bip32_kholaw_key_derivator_base import Bip32KholawEd25519KeyDerivatorBase
+from bip_utils.ecc import Ed25519KholawPrivateKey, EllipticCurve, IPoint
+from ..utils.misc import BytesUtils, IntegerUtils
+
+
+class Bip32KholawEd25519KeyDerivator(Bip32KholawEd25519KeyDerivatorBase):
+    """
+    BIP32 Khovratovich/Law ed25519 key derivator class.
+    It allows keys derivation for ed25519 curves in according to BIP32 Khovratovich/Law.
+    """
+
+    @staticmethod
+    def _SerializeIndex(index: Bip32KeyIndex) -> bytes:
+        """
+        Serialize key index.
+
+        Args:
+            index (Bip32KeyIndex object): Key index
+
+        Returns:
+            bytes: Serialized index
+        """
+        return index.ToBytes(endianness="little")
+
+    @staticmethod
+    def _NewPrivateKeyLeftPart(zl_bytes: bytes,
+                               kl_bytes: bytes,
+                               curve: EllipticCurve) -> bytes:
+        """
+        Compute the new private key left part for private derivation.
+
+        Args:
+            zl_bytes (bytes)            : Leftmost Z 32-byte
+            kl_bytes (bytes)            : Leftmost private key 32-byte
+            curve (EllipticCurve object): EllipticCurve object
+
+        Returns:
+            bytes: Leftmost new private key 32-byte
+        """
+        zl_int = BytesUtils.ToInteger(zl_bytes[:28], endianness="little")
+        kl_int = BytesUtils.ToInteger(kl_bytes, endianness="little")
+
+        prvl_int = (zl_int * 8) + kl_int
+        # Discard child if multiple of curve order
+        if prvl_int % curve.Order() == 0:
+            raise Bip32KeyError("Computed child key is not valid, very unlucky index")
+
+        return IntegerUtils.ToBytes(prvl_int,
+                                    bytes_num=Ed25519KholawPrivateKey.Length() // 2,
+                                    endianness="little")
+
+    @staticmethod
+    def _NewPrivateKeyRightPart(zr_bytes: bytes,
+                                kr_bytes: bytes) -> bytes:
+        """
+        Compute the new private key right part for private derivation.
+
+        Args:
+            zr_bytes (bytes): Rightmost Z 32-byte
+            kr_bytes (bytes): Rightmost private key 32-byte
+
+        Returns:
+            bytes: Rightmost new private key 32-byte
+        """
+        zr_int = BytesUtils.ToInteger(zr_bytes, endianness="little")
+        kpr_int = BytesUtils.ToInteger(kr_bytes, endianness="little")
+        kr_int = (zr_int + kpr_int) % (2 ** 256)
+
+        return IntegerUtils.ToBytes(kr_int,
+                                    bytes_num=Ed25519KholawPrivateKey.Length() // 2,
+                                    endianness="little")
+
+    @staticmethod
+    def _NewPublicKeyPoint(pub_key: Bip32PublicKey,
+                           zl_bytes: bytes) -> IPoint:
+        """
+        Compute new public key point for public derivation.
+
+        Args:
+            pub_key (Bip32PublicKey object): Bip32PublicKey object
+            zl_bytes (bytes)               : Leftmost Z 32-byte
+
+        Returns:
+            IPoint object: IPoint object
+        """
+
+        # Compute the new public key point: PKEY + 8ZL * G
+        zl_int = BytesUtils.ToInteger(zl_bytes[:28], endianness="little")
+        return pub_key.Point() + ((zl_int * 8) * pub_key.Curve().Generator())

coinex/ccxt/static_dependencies/bip/bip32/kholaw/bip32_kholaw_key_derivator_base.py

@@ -0,0 +1,204 @@
+# 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 BIP32 Khovratovich/Law keys derivation (base).
+Reference: https://github.com/LedgerHQ/orakolo/blob/master/papers/Ed25519_BIP%20Final.pdf
+"""
+
+# Imports
+from abc import ABC, abstractmethod
+from typing import Tuple, Union
+
+from .base import IBip32KeyDerivator
+from .bip32_ex import Bip32KeyError
+from .bip32_key_data import Bip32KeyIndex
+from .bip32_keys import Bip32PrivateKey, Bip32PublicKey
+from bip_utils.ecc import EllipticCurve, IPoint
+from ..utils.crypto import HmacSha512
+
+
+class Bip32KholawEd25519KeyDerivatorBase(IBip32KeyDerivator, ABC):
+    """
+    BIP32 Khovratovich/Law ed25519 key derivator base class.
+    It allows keys derivation for ed25519 curves in according to BIP32 Khovratovich/Law.
+    It shall be inherited by child classes to customize the derivation algorithm.
+    """
+
+    @staticmethod
+    def IsPublicDerivationSupported() -> bool:
+        """
+        Get if public derivation is supported.
+
+        Returns:
+            bool: True if supported, false otherwise.
+        """
+        return True
+
+    @classmethod
+    def CkdPriv(cls,
+                priv_key: Bip32PrivateKey,
+                pub_key: Bip32PublicKey,
+                index: Bip32KeyIndex) -> Tuple[bytes, bytes]:
+        """
+        Derive a child key with the specified index using private derivation.
+
+        Args:
+            priv_key (Bip32PrivateKey object): Bip32PrivateKey object
+            pub_key (Bip32PublicKey object)  : Bip32PublicKey object
+            index (Bip32KeyIndex object)     : Key index
+
+        Returns:
+            tuple[bytes, bytes]: Private key bytes (index 0) and chain code bytes (index 1)
+
+        Raises:
+            Bip32KeyError: If the index results in an invalid key
+        """
+
+        # Get index and key bytes
+        index_bytes = cls._SerializeIndex(index)
+        chain_code_bytes = priv_key.ChainCode().ToBytes()
+        priv_key_bytes = priv_key.Raw().ToBytes()
+        pub_key_bytes = pub_key.RawCompressed().ToBytes()[1:]
+
+        # Compute Z and chain code
+        if index.IsHardened():
+            z_bytes = HmacSha512.QuickDigest(chain_code_bytes,
+                                             b"\x00" + priv_key_bytes + index_bytes)
+            chain_code_bytes = HmacSha512.QuickDigestHalves(chain_code_bytes,
+                                                            b"\x01" + priv_key_bytes + index_bytes)[1]
+        else:
+            z_bytes = HmacSha512.QuickDigest(chain_code_bytes,
+                                             b"\x02" + pub_key_bytes + index_bytes)
+            chain_code_bytes = HmacSha512.QuickDigestHalves(chain_code_bytes,
+                                                            b"\x03" + pub_key_bytes + index_bytes)[1]
+
+        # Compute the left and right part of the new private key
+        hmac_half_len = HmacSha512.DigestSize() // 2
+        kl_bytes = cls._NewPrivateKeyLeftPart(z_bytes[:hmac_half_len],
+                                              priv_key_bytes[:hmac_half_len],
+                                              pub_key.Curve())
+        kr_bytes = cls._NewPrivateKeyRightPart(z_bytes[hmac_half_len:],
+                                               priv_key_bytes[hmac_half_len:])
+
+        return kl_bytes + kr_bytes, chain_code_bytes
+
+    @classmethod
+    def CkdPub(cls,
+               pub_key: Bip32PublicKey,
+               index: Bip32KeyIndex) -> Tuple[Union[bytes, IPoint], bytes]:
+        """
+        Derive a child key with the specified index using public derivation.
+
+        Args:
+            pub_key (Bip32PublicKey object): Bip32PublicKey object
+            index (Bip32KeyIndex object)   : Key index
+
+        Returns:
+            tuple[bytes or IPoint, bytes]: Public key bytes or point (index 0) and chain code bytes (index 1)
+
+        Raises:
+            Bip32KeyError: If the index results in an invalid key
+        """
+
+        # Get index and key bytes
+        index_bytes = cls._SerializeIndex(index)
+        chain_code_bytes = pub_key.ChainCode().ToBytes()
+        pub_key_bytes = pub_key.RawCompressed().ToBytes()[1:]
+
+        # Compute Z and chain code
+        z_bytes = HmacSha512.QuickDigest(chain_code_bytes,
+                                         b"\x02" + pub_key_bytes + index_bytes)
+        chain_code_bytes = HmacSha512.QuickDigestHalves(chain_code_bytes,
+                                                        b"\x03" + pub_key_bytes + index_bytes)[1]
+
+        # Compute the new public key point
+        hmac_half_len = HmacSha512.DigestSize() // 2
+        new_pub_key_point = cls._NewPublicKeyPoint(pub_key,
+                                                   z_bytes[:hmac_half_len])
+        # If the public key is the identity point (0, 1) discard the child
+        if new_pub_key_point.X() == 0 and new_pub_key_point.Y() == 1:
+            raise Bip32KeyError("Computed public child key is not valid, very unlucky index")
+
+        return new_pub_key_point, chain_code_bytes
+
+    #
+    # Abstract methods
+    #
+
+    @staticmethod
+    @abstractmethod
+    def _SerializeIndex(index: Bip32KeyIndex) -> bytes:
+        """
+        Serialize key index.
+
+        Args:
+            index (Bip32KeyIndex object): Key index
+
+        Returns:
+            bytes: Serialized index
+        """
+
+    @staticmethod
+    @abstractmethod
+    def _NewPrivateKeyLeftPart(zl_bytes: bytes,
+                               kl_bytes: bytes,
+                               curve: EllipticCurve) -> bytes:
+        """
+        Compute the new private key left part for private derivation.
+
+        Args:
+            zl_bytes (bytes)            : Leftmost Z 32-byte
+            kl_bytes (bytes)            : Leftmost private key 32-byte
+            curve (EllipticCurve object): EllipticCurve object
+
+        Returns:
+            bytes: Leftmost new private key 32-byte
+        """
+
+    @staticmethod
+    @abstractmethod
+    def _NewPrivateKeyRightPart(zr_bytes: bytes,
+                                kr_bytes: bytes) -> bytes:
+        """
+        Compute the new private key right part for private derivation.
+
+        Args:
+            zr_bytes (bytes): Rightmost Z 32-byte
+            kr_bytes (bytes): Rightmost private key 32-byte
+
+        Returns:
+            bytes: Rightmost new private key 32-byte
+        """
+
+    @staticmethod
+    @abstractmethod
+    def _NewPublicKeyPoint(pub_key: Bip32PublicKey,
+                           zl_bytes: bytes) -> IPoint:
+        """
+        Compute new public key point for public derivation.
+
+        Args:
+            pub_key (Bip32PublicKey object): Bip32PublicKey object
+            zl_bytes (bytes)               : Leftmost Z 32-byte
+
+        Returns:
+            IPoint object: IPoint object
+        """

coinex/ccxt/static_dependencies/bip/bip32/kholaw/bip32_kholaw_mst_key_generator.py

@@ -0,0 +1,119 @@
+# 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 BIP32 Khovratovich/Law master key generation.
+Reference: https://github.com/LedgerHQ/orakolo/blob/master/papers/Ed25519_BIP%20Final.pdf
+"""
+
+# Imports
+from typing import Tuple
+
+from .base import IBip32MstKeyGenerator
+from .slip10.bip32_slip10_mst_key_generator import Bip32Slip10MstKeyGeneratorConst
+from ..utils.crypto import HmacSha256, HmacSha512
+from ..utils.misc import BitUtils
+
+
+class Bip32KholawMstKeyGeneratorConst:
+    """Class container for BIP32 Khovratovich/Law master key generator constants."""
+
+    # Minimum length in bytes for seed
+    SEED_MIN_BYTE_LEN: int = Bip32Slip10MstKeyGeneratorConst.SEED_MIN_BYTE_LEN
+    # HMAC key for generating master key
+    MASTER_KEY_HMAC_KEY: bytes = Bip32Slip10MstKeyGeneratorConst.HMAC_KEY_ED25519_BYTES
+
+
+class Bip32KholawEd25519MstKeyGenerator(IBip32MstKeyGenerator):
+    """
+    BIP32 Khovratovich/Law ed25519 master key generator class.
+    It allows master keys generation in according to BIP32 Khovratovich/Law for ed25519 curve.
+    """
+
+    @classmethod
+    def GenerateFromSeed(cls,
+                         seed_bytes: bytes) -> Tuple[bytes, bytes]:
+        """
+        Generate a master key from the specified seed.
+
+        Args:
+            seed_bytes (bytes): Seed bytes
+
+        Returns:
+            tuple[bytes, bytes]: Private key bytes (index 0) and chain code bytes (index 1)
+
+        Raises:
+            Bip32KeyError: If the seed is not suitable for master key generation
+            ValueError: If seed length is not valid
+        """
+        if len(seed_bytes) < Bip32KholawMstKeyGeneratorConst.SEED_MIN_BYTE_LEN:
+            raise ValueError(f"Invalid seed length ({len(seed_bytes)})")
+
+        # Compute kL and kR
+        kl_bytes, kr_bytes = cls.__HashRepeatedly(seed_bytes, Bip32KholawMstKeyGeneratorConst.MASTER_KEY_HMAC_KEY)
+        # Tweak kL bytes
+        kl_bytes = cls.__TweakMasterKeyBits(kl_bytes)
+
+        # Compute chain code
+        chain_code_bytes = HmacSha256.QuickDigest(Bip32KholawMstKeyGeneratorConst.MASTER_KEY_HMAC_KEY,
+                                                  b"\x01" + seed_bytes)
+
+        return kl_bytes + kr_bytes, chain_code_bytes
+
+    @classmethod
+    def __HashRepeatedly(cls,
+                         data_bytes: bytes,
+                         hmac_key_bytes: bytes) -> Tuple[bytes, bytes]:
+        """
+        Continue to hash the data bytes until the third-highest bit of the last byte is not zero.
+
+        Args:
+            data_bytes (bytes)    : Data bytes
+            hmac_key_bytes (bytes): HMAC key bytes
+
+        Returns:
+            tuple[bytes, bytes]: Two halves of the computed hash
+        """
+        kl_bytes, kr_bytes = HmacSha512.QuickDigestHalves(hmac_key_bytes,
+                                                          data_bytes)
+        if BitUtils.AreBitsSet(kl_bytes[31], 0x20):
+            return cls.__HashRepeatedly(kl_bytes + kr_bytes, hmac_key_bytes)
+        return kl_bytes, kr_bytes
+
+    @staticmethod
+    def __TweakMasterKeyBits(key_bytes: bytes) -> bytes:
+        """
+        Tweak master key bits.
+
+        Args:
+            key_bytes (bytes): Key bytes
+
+        Returns:
+            bytes: Tweaked key bytes
+        """
+        key_bytes = bytearray(key_bytes)
+        # Clear the lowest 3 bits of the first byte of kL
+        key_bytes[0] = BitUtils.ResetBits(key_bytes[0], 0x07)
+        # Clear the highest bit of the last byte of kL
+        key_bytes[31] = BitUtils.ResetBits(key_bytes[31], 0x80)
+        # Set the second-highest bit of the last byte of kL
+        key_bytes[31] = BitUtils.SetBits(key_bytes[31], 0x40)
+
+        return bytes(key_bytes)

coinex/ccxt/static_dependencies/bip/bip32/slip10/__init__.py

@@ -0,0 +1 @@
+from .bip32_slip10_secp256k1 import Bip32Secp256k1, Bip32Slip10Secp256k1