bitmart 0.0.116__py3-none-any.whl

bitmart/ccxt/static_dependencies/README.md

@@ -0,0 +1 @@
+// TODO: add web3

bitmart/ccxt/static_dependencies/__init__.py

@@ -0,0 +1 @@
+__all__ = ['ecdsa', 'keccak', 'aiohttp_socks', 'ethereum', 'parsimonious', 'toolz', 'starknet', 'marshmallow', 'marshmallow_oneofschema', 'lark', 'starkware', 'sympy']

bitmart/ccxt/static_dependencies/bip/__init__.py

@@ -0,0 +1,6 @@
+from .bip32 import *
+from .bip44 import *
+from .utils import *
+from .conf import *
+
+__all__ = [ 'bip32', 'bip44', 'utils', 'conf' ]

bitmart/ccxt/static_dependencies/bip/addr/P2PKH_addr.py

@@ -0,0 +1,205 @@
+# 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 P2PKH address encoding/decoding."""
+
+# Imports
+from enum import Enum, auto, unique
+from typing import Any, Union
+
+from .addr_dec_utils import AddrDecUtils
+from .addr_key_validator import AddrKeyValidator
+from .iaddr_decoder import IAddrDecoder
+from .iaddr_encoder import IAddrEncoder
+from ..base58 import Base58Alphabets, Base58ChecksumError, Base58Decoder, Base58Encoder
+from ..bech32 import BchBech32Decoder, BchBech32Encoder, Bech32ChecksumError
+from ..ecc import IPublicKey
+from ..utils.crypto import Hash160
+from ..utils.misc import BytesUtils
+
+
+@unique
+class P2PKHPubKeyModes(Enum):
+    """Enumerative for P2PKH public key modes."""
+
+    COMPRESSED = auto()
+    UNCOMPRESSED = auto()
+
+
+class P2PKHAddrDecoder(IAddrDecoder):
+    """
+    P2PKH address decoder class.
+    It allows the Pay-to-Public-Key-Hash address decoding.
+    """
+
+    @staticmethod
+    def DecodeAddr(addr: str,
+                   **kwargs: Any) -> bytes:
+        """
+        Decode a P2PKH address to bytes.
+
+        Args:
+            addr (str): Address string
+
+        Other Parameters:
+            net_ver (bytes)                        : Expected net address version
+            base58_alph (Base58Alphabets, optional): Base58 alphabet (default: Bitcoin alphabet)
+
+        Returns:
+            bytes: Public key hash bytes
+
+        Raises:
+            ValueError: If the address encoding is not valid
+        """
+        net_ver_bytes = kwargs["net_ver"]
+        base58_alph = kwargs.get("base58_alph", Base58Alphabets.BITCOIN)
+
+        try:
+            addr_dec_bytes = Base58Decoder.CheckDecode(addr, base58_alph)
+        except Base58ChecksumError as ex:
+            raise ValueError("Invalid base58 checksum") from ex
+
+        # Validate length
+        AddrDecUtils.ValidateLength(addr_dec_bytes,
+                                    Hash160.DigestSize() + len(net_ver_bytes))
+        # Validate and remove prefix
+        return AddrDecUtils.ValidateAndRemovePrefix(addr_dec_bytes, net_ver_bytes)
+
+
+class P2PKHAddrEncoder(IAddrEncoder):
+    """
+    P2PKH address encoder class.
+    It allows the Pay-to-Public-Key-Hash address encoding.
+    """
+
+    @staticmethod
+    def EncodeKey(pub_key: Union[bytes, IPublicKey],
+                  **kwargs: Any) -> str:
+        """
+        Encode a public key to P2PKH address.
+
+        Args:
+            pub_key (bytes or IPublicKey): Public key bytes or object
+
+        Other Parameters:
+            net_ver (bytes)                          : Net address version
+            base58_alph (Base58Alphabets, optional)  : Base58 alphabet, Bitcoin alphabet by default
+            pub_key_mode (P2PKHPubKeyModes, optional): Public key mode, compressed key by default
+
+        Returns:
+            str: Address string
+
+        Raises:
+            ValueError: If the public key is not valid
+            TypeError: If the public key is not secp256k1
+        """
+        net_ver_bytes = kwargs["net_ver"]
+        base58_alph = kwargs.get("base58_alph", Base58Alphabets.BITCOIN)
+        pub_key_mode = kwargs.get("pub_key_mode", P2PKHPubKeyModes.COMPRESSED)
+
+        pub_key_obj = AddrKeyValidator.ValidateAndGetSecp256k1Key(pub_key)
+        pub_key_bytes = (pub_key_obj.RawCompressed().ToBytes()
+                         if pub_key_mode == P2PKHPubKeyModes.COMPRESSED
+                         else pub_key_obj.RawUncompressed().ToBytes())
+
+        return Base58Encoder.CheckEncode(net_ver_bytes + Hash160.QuickDigest(pub_key_bytes), base58_alph)
+
+
+class BchP2PKHAddrDecoder(IAddrDecoder):
+    """
+    Bitcoin Cash P2PKH address decoder class.
+    It allows the Bitcoin Cash P2PKH decoding.
+    """
+
+    @staticmethod
+    def DecodeAddr(addr: str,
+                   **kwargs: Any) -> bytes:
+        """
+        Decode a Bitcoin Cash P2PKH address to bytes.
+
+        Args:
+            addr (str): Address string
+
+        Other Parameters:
+            hrp (str)      : Expected HRP
+            net_ver (bytes): Expected net address version
+
+        Returns:
+            bytes: Public key hash bytes
+
+        Raises:
+            ValueError: If the address encoding is not valid
+        """
+        hrp = kwargs["hrp"]
+        net_ver_bytes = kwargs["net_ver"]
+
+        try:
+            net_ver_bytes_got, addr_dec_bytes = BchBech32Decoder.Decode(hrp, addr)
+        except Bech32ChecksumError as ex:
+            raise ValueError("Invalid bech32 checksum") from ex
+
+        # Check net version
+        if net_ver_bytes != net_ver_bytes_got:
+            raise ValueError(f"Invalid net version (expected {BytesUtils.ToHexString(net_ver_bytes)}, "
+                             f"got {BytesUtils.ToHexString(net_ver_bytes_got)})")
+        # Validate length
+        AddrDecUtils.ValidateLength(addr_dec_bytes,
+                                    Hash160.DigestSize())
+        return addr_dec_bytes
+
+
+class BchP2PKHAddrEncoder(IAddrEncoder):
+    """
+    Bitcoin Cash P2PKH address encoder class.
+    It allows the Bitcoin Cash P2PKH encoding.
+    """
+
+    @staticmethod
+    def EncodeKey(pub_key: Union[bytes, IPublicKey],
+                  **kwargs: Any) -> str:
+        """
+        Encode a public key to Bitcoin Cash P2PKH address.
+
+        Args:
+            pub_key (bytes or IPublicKey): Public key bytes or object
+
+        Other Parameters:
+            hrp (str)      : HRP
+            net_ver (bytes): Net address version
+
+        Returns:
+            str: Address string
+
+        Raises:
+            ValueError: If the public key is not valid
+            TypeError: If the public key is not secp256k1
+        """
+        hrp = kwargs["hrp"]
+        net_ver_bytes = kwargs["net_ver"]
+
+        pub_key_obj = AddrKeyValidator.ValidateAndGetSecp256k1Key(pub_key)
+        return BchBech32Encoder.Encode(hrp,
+                                       net_ver_bytes,
+                                       Hash160.QuickDigest(pub_key_obj.RawCompressed().ToBytes()))
+
+
+# Deprecated: only for compatibility, Encoder classes shall be used instead
+P2PKHAddr = P2PKHAddrEncoder
+BchP2PKHAddr = BchP2PKHAddrEncoder

bitmart/ccxt/static_dependencies/bip/addr/__init__.py

@@ -0,0 +1,5 @@
+from .iaddr_encoder import IAddrEncoder
+from .P2PKH_addr import (
+    BchP2PKHAddr, BchP2PKHAddrDecoder, BchP2PKHAddrEncoder, P2PKHAddr, P2PKHAddrDecoder, P2PKHAddrEncoder,
+    P2PKHPubKeyModes
+)

bitmart/ccxt/static_dependencies/bip/addr/addr_dec_utils.py

@@ -0,0 +1,125 @@
+# 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 utility functions for address decoding."""
+
+# Imports
+from typing import Callable, Tuple, Type, TypeVar, Union
+
+from ..ecc import IPublicKey
+from ..utils.misc import BytesUtils
+
+
+BytesOrStr = TypeVar("BytesOrStr", bytes, str)
+
+
+class AddrDecUtils:
+    """Class container for address decoding utility functions."""
+
+    @staticmethod
+    def ValidateAndRemovePrefix(addr: BytesOrStr,
+                                prefix: BytesOrStr) -> BytesOrStr:
+        """
+        Validate and remove prefix from an address.
+
+        Args:
+            addr (bytes or str)  : Address string or bytes
+            prefix (bytes or str): Address prefix
+
+        Returns:
+            bytes or str: Address string or bytes with prefix removed
+
+        Raises:
+            ValueError: If the prefix is not valid
+        """
+        prefix_got = addr[:len(prefix)]
+        if prefix != prefix_got:
+            raise ValueError(f"Invalid prefix (expected {prefix!r}, got {prefix_got!r})")
+        return addr[len(prefix):]
+
+    @staticmethod
+    def ValidateLength(addr: Union[bytes, str],
+                       len_exp: int) -> None:
+        """
+        Validate address length.
+
+        Args:
+            addr (str)   : Address string or bytes
+            len_exp (int): Expected address length
+
+        Raises:
+            ValueError: If the length is not valid
+        """
+        if len(addr) != len_exp:
+            raise ValueError(f"Invalid length (expected {len_exp}, got {len(addr)})")
+
+    @staticmethod
+    def ValidatePubKey(pub_key_bytes: bytes,
+                       pub_key_cls: Type[IPublicKey]) -> None:
+        """
+        Validate address length.
+
+        Args:
+            pub_key_bytes (bytes)   : Public key bytes
+            pub_key_cls (IPublicKey): Public key class type
+
+        Raises:
+            ValueError: If the public key is not valid
+        """
+        if not pub_key_cls.IsValidBytes(pub_key_bytes):
+            raise ValueError(f"Invalid {pub_key_cls.CurveType()} "
+                             f"public key {BytesUtils.ToHexString(pub_key_bytes)}")
+
+    @staticmethod
+    def ValidateChecksum(payload_bytes: bytes,
+                         checksum_bytes_exp: bytes,
+                         checksum_fct: Callable[[bytes], bytes]) -> None:
+        """
+        Validate address checksum.
+
+        Args:
+            payload_bytes (bytes)     : Payload bytes
+            checksum_bytes_exp (bytes): Expected checksum bytes
+            checksum_fct (function)   : Function for computing checksum
+
+        Raises:
+            ValueError: If the computed checksum is not equal tot he specified one
+        """
+        checksum_bytes_got = checksum_fct(payload_bytes)
+        if checksum_bytes_exp != checksum_bytes_got:
+            raise ValueError(f"Invalid checksum (expected {BytesUtils.ToHexString(checksum_bytes_exp)}, "
+                             f"got {BytesUtils.ToHexString(checksum_bytes_got)})")
+
+    @staticmethod
+    def SplitPartsByChecksum(addr_bytes: bytes,
+                             checksum_len: int) -> Tuple[bytes, bytes]:
+        """
+        Split address in two parts, considering the checksum at the end of it.
+
+        Args:
+            addr_bytes (bytes): Address bytes
+            checksum_len (int): Checksum length
+
+        Returns:
+            tuple[bytes, bytes]: Payload bytes (index 0) and checksum bytes (index 1)
+        """
+        checksum_bytes = addr_bytes[-1 * checksum_len:]
+        payload_bytes = addr_bytes[:-1 * checksum_len]
+        return payload_bytes, checksum_bytes

bitmart/ccxt/static_dependencies/bip/addr/addr_key_validator.py

@@ -0,0 +1,162 @@
+# 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 utility functions for validating address public keys."""
+
+# Imports
+from typing import Type, Union
+
+from ..ecc import (
+    Secp256k1PublicKey, IPublicKey,
+    # Ed25519Blake2bPublicKey, Ed25519MoneroPublicKey, Ed25519PublicKey, EllipticCurveGetter,
+    # Nist256p1PublicKey, Secp256k1PublicKey, Sr25519PublicKey
+)
+
+
+class AddrKeyValidator:
+    """Class container for address utility functions."""
+
+    # @staticmethod
+    # def ValidateAndGetEd25519Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a ed25519 public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not ed25519
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Ed25519PublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetEd25519Blake2bKey(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a ed25519-blake2b public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not ed25519-blake2b
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Ed25519Blake2bPublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetEd25519MoneroKey(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a ed25519-monero public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not ed25519-monero
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Ed25519MoneroPublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetNist256p1Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a nist256p1 public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not nist256p1
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Nist256p1PublicKey)
+
+    @staticmethod
+    def ValidateAndGetSecp256k1Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+        """
+        Validate and get a secp256k1 public key.
+
+        Args:
+            pub_key (bytes or IPublicKey object): Public key bytes or object
+
+        Returns:
+            IPublicKey object: IPublicKey object
+
+        Raises:
+            TypeError: If the public key is not secp256k1
+            ValueError: If the public key is not valid
+        """
+        return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Secp256k1PublicKey)
+
+    # @staticmethod
+    # def ValidateAndGetSr25519Key(pub_key: Union[bytes, IPublicKey]) -> IPublicKey:
+    #     """
+    #     Validate and get a sr25519 public key.
+
+    #     Args:
+    #         pub_key (bytes or IPublicKey object): Public key bytes or object
+
+    #     Returns:
+    #         IPublicKey object: IPublicKey object
+
+    #     Raises:
+    #         TypeError: If the public key is not sr25519
+    #         ValueError: If the public key is not valid
+    #     """
+    #     return AddrKeyValidator.__ValidateAndGetGenericKey(pub_key, Sr25519PublicKey)
+
+    @staticmethod
+    def __ValidateAndGetGenericKey(pub_key: Union[bytes, IPublicKey],
+                                   pub_key_cls: Type[IPublicKey]) -> IPublicKey:
+        """
+        Validate and get a generic public key.
+
+        Args:
+            pub_key (bytes or IPublicKey object): Public key bytes or object
+            pub_key_cls (IPublicKey)            : Public key class type
+
+        Returns:
+            IPublicKey object: IPublicKey object
+
+        Raises:
+            TypeError: If the public key is not of the correct class type
+            ValueError: If the public key is not valid
+        """
+        if isinstance(pub_key, bytes):
+            pub_key = pub_key_cls.FromBytes(pub_key)
+        elif not isinstance(pub_key, pub_key_cls):
+            curve = EllipticCurveGetter.FromType(pub_key_cls.CurveType())
+            raise TypeError(f"A {curve.Name()} public key is required"
+                            f"(expected: {pub_key_cls}, got: {type(pub_key)}")
+
+        return pub_key

bitmart/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
+        """

bitmart/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)
+        """

bitmart/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