hive-nectar 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

nectarbase/memo.py

@@ -3,7 +3,6 @@ import hashlib
 from binascii import hexlify, unhexlify
 
 from nectargraphenebase.base58 import base58decode, base58encode
-from nectargraphenebase.py23 import py23_bytes
 from nectargraphenebase.types import varintdecode
 
 try:
@@ -50,7 +49,7 @@ def init_aes(shared_secret, nonce):
     " Shared Secret "
     ss = hashlib.sha512(unhexlify(shared_secret)).digest()
     " Seed "
-    seed = py23_bytes(str(nonce), "ascii") + hexlify(ss)
+    seed = bytes(str(nonce), "ascii") + hexlify(ss)
     seed_digest = hexlify(hashlib.sha512(seed).digest()).decode("ascii")
     " AES "
     key = unhexlify(seed_digest[0:64])
@@ -76,7 +75,7 @@ def init_aes_bts(shared_secret, nonce):
     return AES.new(key, AES.MODE_CBC, iv)
 
 
-def init_aes(shared_secret, nonce):
+def init_aes2(shared_secret, nonce):
     """Initialize AES instance
     :param hex shared_secret: Shared Secret to use as encryption key
     :param int nonce: Random nonce
@@ -121,7 +120,7 @@ def encode_memo_bts(priv, pub, nonce, message):
     shared_secret = get_shared_secret(priv, pub)
     aes = init_aes_bts(shared_secret, nonce)
     " Checksum "
-    raw = py23_bytes(message, "utf8")
+    raw = bytes(message, "utf8")
     checksum = hashlib.sha256(raw).digest()
     raw = checksum[0:4] + raw
     " Padding "
@@ -146,7 +145,7 @@ def decode_memo_bts(priv, pub, nonce, message):
     shared_secret = get_shared_secret(priv, pub)
     aes = init_aes_bts(shared_secret, nonce)
     " Encryption "
-    raw = py23_bytes(message, "ascii")
+    raw = bytes(message, "ascii")
     cleartext = aes.decrypt(unhexlify(raw))
     " Checksum "
     checksum = cleartext[0:4]
@@ -170,9 +169,9 @@ def encode_memo(priv, pub, nonce, message, **kwargs):
     :rtype: hex
     """
     shared_secret = get_shared_secret(priv, pub)
-    aes, check = init_aes(shared_secret, nonce)
+    aes, check = init_aes2(shared_secret, nonce)
     " Padding "
-    raw = py23_bytes(message, "utf8")
+    raw = bytes(message, "utf8")
     raw = _pad(raw, 16)
     " Encryption "
     cipher = hexlify(aes.encrypt(raw)).decode("ascii")
@@ -186,7 +185,7 @@ def encode_memo(priv, pub, nonce, message, **kwargs):
         "prefix": prefix,
     }
     tx = Memo(**s)
-    return "#" + base58encode(hexlify(py23_bytes(tx)).decode("ascii"))
+    return "#" + base58encode(hexlify(bytes(tx)).decode("ascii"))
 
 
 def extract_memo_data(message):
@@ -225,7 +224,7 @@ def decode_memo(priv, message):
         raise ValueError("Incorrect PrivateKey")
 
     # Init encryption
-    aes, checksum = init_aes(shared_secret, nonce)
+    aes, checksum = init_aes2(shared_secret, nonce)
     # Check
     if not check == checksum:
         raise AssertionError("Checksum failure")
@@ -234,7 +233,7 @@ def decode_memo(priv, message):
     numBytes = 16 - len(cipher) % 16
     n = 16 - numBytes
     message = cipher[n:]
-    message = aes.decrypt(unhexlify(py23_bytes(message, "ascii")))
+    message = aes.decrypt(unhexlify(bytes(message, "ascii")))
     message = _unpad(message, 16)
     n = varintdecode(message)
     if (len(message) - n) > 0 and (len(message) - n) < 8:

nectarbase/objects.py

@@ -8,7 +8,6 @@ from nectargraphenebase.account import PublicKey
 from nectargraphenebase.chains import known_chains
 from nectargraphenebase.objects import GrapheneObject, isArgsThisClass
 from nectargraphenebase.objects import Operation as GPHOperation
-from nectargraphenebase.py23 import py23_bytes, string_types
 from nectargraphenebase.types import (
     Array,
     Bytes,
@@ -38,7 +37,7 @@ def value_to_decimal(value, decimal_places):
 class Amount(object):
     def __init__(self, d, prefix=default_prefix, json_str=False):
         self.json_str = json_str
-        if isinstance(d, string_types):
+        if isinstance(d, str):
             self.amount, self.symbol = d.strip().split(" ")
             self.precision = None
             for c in known_chains:
@@ -113,7 +112,7 @@ class Amount(object):
         return (
             struct.pack("<q", int(self.amount))
             + struct.pack("<b", self.precision)
-            + py23_bytes(symbol, "ascii")
+            + bytes(symbol, "ascii")
         )
 
     def __str__(self):
@@ -150,7 +149,7 @@ class Operation(GPHOperation):
         # return json.loads(str(json.dumps([self.name, self.op.toJson()])))
 
     def __bytes__(self):
-        return py23_bytes(Id(self.opId)) + py23_bytes(self.op)
+        return bytes(Id(self.opId)) + bytes(self.op)
 
     def __str__(self):
         if self.appbase:
@@ -364,7 +363,7 @@ class CommentOptionExtensions(Static_variant):
     """
 
     def __init__(self, o):
-        if type(o) == dict and "type" in o and "value" in o:
+        if isinstance(o, dict) and "type" in o and "value" in o:
             if o["type"] == "comment_payout_beneficiaries":
                 type_id = 0
             else:

nectarbase/operations.py

@@ -5,7 +5,6 @@ from binascii import hexlify
 from collections import OrderedDict
 
 from nectargraphenebase.account import PublicKey
-from nectargraphenebase.py23 import PY2, PY3, string_types
 from nectargraphenebase.types import (
     Array,
     Bool,
@@ -58,7 +57,7 @@ class Transfer(GrapheneObject):
         if isinstance(kwargs["memo"], dict):
             kwargs["memo"]["prefix"] = prefix
             memo = Optional(Memo(**kwargs["memo"]))
-        elif isinstance(kwargs["memo"], string_types):
+        elif isinstance(kwargs["memo"], str):
             memo = String(kwargs["memo"])
         else:
             memo = Optional(Memo(kwargs["memo"]))
@@ -90,7 +89,7 @@ class Recurring_transfer(GrapheneObject):
         if isinstance(kwargs["memo"], dict):
             kwargs["memo"]["prefix"] = prefix
             memo = Optional(Memo(**kwargs["memo"]))
-        elif isinstance(kwargs["memo"], string_types):
+        elif isinstance(kwargs["memo"], str):
             memo = String(kwargs["memo"])
         else:
             memo = Optional(Memo(kwargs["memo"]))
@@ -539,10 +538,8 @@ class Witness_set_properties(GrapheneObject):
         for k in kwargs["props"]:
             if k[0] in ["key", "new_signing_key"]:
                 continue
-            if isinstance(k[1], str) and PY3:
+            if isinstance(k[1], str):
                 is_hex = re.fullmatch(r"[0-9a-fA-F]+", k[1] or "") is not None
-            elif isinstance(k[1], str) and PY2:
-                is_hex = re.match(r"[0-9a-fA-F]+", k[1] or "") is not None
             else:
                 is_hex = False
             if isinstance(k[1], int) and k[0] in [
@@ -991,7 +988,6 @@ class Transfer_from_savings(GrapheneObject):
         json_str = kwargs.get("json_str", False)
         if "memo" not in kwargs:
             kwargs["memo"] = ""
-
         super(Transfer_from_savings, self).__init__(
             OrderedDict(
                 [

nectarbase/version.py

@@ -1,3 +1,3 @@
 """THIS FILE IS GENERATED FROM nectar PYPROJECT.TOML."""
 
-version = "0.0.5"
+version = "0.0.7"

nectargraphenebase/__init__.py

@@ -23,5 +23,4 @@ __all__ = [
     "signedtransactions",
     "unsignedtransactions",
     "objecttypes",
-    "py23",
 ]

nectargraphenebase/account.py

@@ -1,12 +1,10 @@
 # -*- coding: utf-8 -*-
 import binascii
 import bisect
-import codecs
 import hashlib
 import itertools
 import os
 import re
-import sys
 import unicodedata
 from binascii import hexlify, unhexlify
 
@@ -17,7 +15,6 @@ from .bip32 import BIP32Key, parse_path
 from .dictionary import words as BrainKeyDictionary
 from .dictionary import words_bip39 as MnemonicDictionary
 from .prefix import Prefix
-from .py23 import PY2, py23_bytes
 
 PBKDF2_ROUNDS = 2048
 
@@ -55,7 +52,7 @@ class PasswordKey(Prefix):
         else:
             seed = self.account + self.role + self.password
         seed = self.normalize(seed)
-        a = py23_bytes(seed, "utf8")
+        a = bytes(seed, "utf8")
         s = hashlib.sha256(a).digest()
         return PrivateKey(hexlify(s).decode("ascii"), prefix=self.prefix)
 
@@ -121,13 +118,13 @@ class BrainKey(Prefix):
         number
         """
         encoded = "%s %d" % (self.brainkey, self.sequence)
-        a = py23_bytes(encoded, "ascii")
+        a = bytes(encoded, "ascii")
         s = hashlib.sha256(hashlib.sha512(a).digest()).digest()
         return PrivateKey(hexlify(s).decode("ascii"), prefix=self.prefix)
 
     def get_blind_private(self):
         """Derive private key from the brain key (and no sequence number)"""
-        a = py23_bytes(self.brainkey, "ascii")
+        a = bytes(self.brainkey, "ascii")
         return PrivateKey(hashlib.sha256(a).hexdigest(), prefix=self.prefix)
 
     def get_public(self):
@@ -149,12 +146,7 @@ class BrainKey(Prefix):
             raise AssertionError()
         for j in range(0, word_count):
             urand = os.urandom(2)
-            if isinstance(urand, str):
-                urand = py23_bytes(urand, "ascii")
-            if PY2:
-                num = int(codecs.encode(urand[::-1], "hex"), 16)
-            else:
-                num = int.from_bytes(urand, byteorder="little")
+            num = int.from_bytes(urand, byteorder="little")
             rndMult = num / 2**16  # returns float between 0..1 (inclusive)
             wIdx = int(round(len(dict_lines) * rndMult))
             brainkey[j] = dict_lines[wIdx]
@@ -180,7 +172,7 @@ class Mnemonic(object):
         """
         if strength not in [128, 160, 192, 224, 256]:
             raise ValueError(
-                "Strength should be one of the following [128, 160, 192, 224, 256], but it is not (%d)."
+                "Strength should be one of the following: [128, 160, 192, 224, 256], but it is not (%d)."
                 % strength
             )
         return self.to_mnemonic(os.urandom(strength // 8))
@@ -223,18 +215,11 @@ class Mnemonic(object):
                     entropy[ii] |= 1 << (7 - jj)
         # Take the digest of the entropy.
         hashBytes = hashlib.sha256(entropy).digest()
-        if sys.version < "3":
-            hashBits = list(
-                itertools.chain.from_iterable(
-                    ([ord(c) & (1 << (7 - i)) != 0 for i in range(8)] for c in hashBytes)
-                )
-            )
-        else:
-            hashBits = list(
-                itertools.chain.from_iterable(
-                    ([c & (1 << (7 - i)) != 0 for i in range(8)] for c in hashBytes)
-                )
+        hashBits = list(
+            itertools.chain.from_iterable(
+                ([c & (1 << (7 - i)) != 0 for i in range(8)] for c in hashBytes)
             )
+        )
         # Check all the checksum bits.
         for i in range(checksumLengthBits):
             if concatBits[entropyLengthBits + i] != hashBits[i]:
@@ -308,13 +293,7 @@ class Mnemonic(object):
     @classmethod
     def normalize_string(cls, txt):
         """Normalizes strings"""
-        if isinstance(txt, str if sys.version < "3" else bytes):
-            utxt = txt.decode("utf8")
-        elif isinstance(txt, unicode if sys.version < "3" else str):  # noqa: F821
-            utxt = txt
-        else:
-            raise TypeError("String value expected")
-
+        utxt = txt.decode("utf8")
         return unicodedata.normalize("NFKD", utxt)
 
     @classmethod
@@ -535,7 +514,7 @@ class Address(Prefix):
 
     def __bytes__(self):
         """Returns the raw content of the ``Base58CheckEncoded`` address"""
-        return py23_bytes(self._address)
+        return bytes(self._address)
 
 
 class GrapheneAddress(Address):
@@ -683,7 +662,7 @@ class PublicKey(Prefix):
 
     def __bytes__(self):
         """Returns the raw public key (has length 33)"""
-        return py23_bytes(self._pk)
+        return bytes(self._pk)
 
     def __lt__(self, other):
         """For sorting of public keys (due to graphene),
@@ -774,13 +753,13 @@ class PrivateKey(Prefix):
         sequence number
         """
         encoded = "%s %d" % (str(self), sequence)
-        a = py23_bytes(encoded, "ascii")
+        a = bytes(encoded, "ascii")
         s = hashlib.sha256(hashlib.sha512(a).digest()).digest()
         return PrivateKey(hexlify(s).decode("ascii"), prefix=self.pubkey.prefix)
 
     def child(self, offset256):
         """Derive new private key from this key and a sha256 "offset" """
-        a = py23_bytes(self.pubkey) + offset256
+        a = bytes(self.pubkey) + offset256
         s = hashlib.sha256(a).digest()
         return self.derive_from_seed(s)
 
@@ -789,7 +768,7 @@ class PrivateKey(Prefix):
         Here, the key itself serves as a `seed`, and `offset`
         is expected to be a sha256 digest.
         """
-        seed = int(hexlify(py23_bytes(self)).decode("ascii"), 16)
+        seed = int(hexlify(bytes(self)).decode("ascii"), 16)
         z = int(hexlify(offset).decode("ascii"), 16)
         order = ecdsa.SECP256k1.order
         secexp = (seed + z) % order
@@ -816,7 +795,7 @@ class PrivateKey(Prefix):
 
     def __bytes__(self):
         """Returns the raw private key"""
-        return py23_bytes(self._wif)
+        return bytes(self._wif)
 
 
 class BitcoinAddress(Address):

nectargraphenebase/base58.py

@@ -5,7 +5,6 @@ import string
 from binascii import hexlify, unhexlify
 
 from .prefix import Prefix
-from .py23 import integer_types, py23_bytes, py23_chr, string_types
 
 log = logging.getLogger(__name__)
 
@@ -99,14 +98,12 @@ BASE58_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
 
 def base58decode(base58_str):
-    base58_text = py23_bytes(base58_str, "ascii")
+    base58_text = bytes(base58_str, "ascii")
     n = 0
     leading_zeroes_count = 0
     for b in base58_text:
-        if isinstance(b, integer_types):
-            n = n * 58 + BASE58_ALPHABET.find(py23_chr(b))
-        else:
-            n = n * 58 + BASE58_ALPHABET.find(b)
+        # b is always int in Python 3 when iterating bytes
+        n = n * 58 + BASE58_ALPHABET.find(bytes([b]))
         if n == 0:
             leading_zeroes_count += 1
     res = bytearray()
@@ -120,7 +117,7 @@ def base58decode(base58_str):
 
 
 def base58encode(hexstring):
-    byteseq = py23_bytes(unhexlify(py23_bytes(hexstring, "ascii")))
+    byteseq = bytes(unhexlify(bytes(hexstring, "ascii")))
     n = 0
     leading_zeroes_count = 0
     for c in byteseq:
@@ -156,7 +153,7 @@ def b58decode(v):
 
 
 def base58CheckEncode(version, payload):
-    if isinstance(version, string_types):
+    if isinstance(version, str):
         s = version + payload
     else:
         s = ("%.2x" % version) + payload

nectargraphenebase/bip32.py

@@ -17,7 +17,6 @@ from ecdsa.curves import SECP256k1
 from ecdsa.numbertheory import square_root_mod_prime as sqrt_mod
 
 from nectargraphenebase.base58 import base58CheckDecode, base58CheckEncode
-from nectargraphenebase.py23 import py23_bytes
 
 VerifyKey = ecdsa.VerifyingKey.from_public_point
 SigningKey = ecdsa.SigningKey.from_string
@@ -45,7 +44,7 @@ EX_TEST_PUBLIC = [
 
 
 def int_to_hex(x):
-    return py23_bytes(hex(x)[2:], encoding="utf-8")
+    return bytes(hex(x)[2:], encoding="utf-8")
 
 
 def parse_path(nstr, as_bytes=False):
@@ -123,11 +122,7 @@ class BIP32Key(object):
             raise ValueError("unknown extended key version")
 
         # Extract remaining fields
-        # Python 2.x compatibility
-        if type(raw[4]) == int:
-            depth = raw[4]
-        else:
-            depth = ord(raw[4])
+        depth = raw[4]
         fpr = raw[5:9]
         child = struct.unpack(">L", raw[9:13])[0]
         chain = raw[13:45]
@@ -138,8 +133,7 @@ class BIP32Key(object):
             secret = secret[1:]
         else:
             # Recover public curve point from compressed key
-            # Python3 FIX
-            lsb = secret[0] & 1 if type(secret[0]) == int else ord(secret[0]) & 1
+            lsb = secret[0] & 1
             x = int.from_bytes(secret[1:], "big")
             ys = (x**3 + 7) % FIELD_ORDER  # y^2 = x^3 + 7 mod p
             y = sqrt_mod(ys, FIELD_ORDER)
@@ -167,10 +161,10 @@ class BIP32Key(object):
         Create a public or private BIP32Key using key material and chain code.
 
         secret   This is the source material to generate the keypair, either a
-                 32-byte string representation of a private key, or the ECDSA
+                 32-byte str representation of a private key, or the ECDSA
                  library object representing a public key.
 
-        chain    This is a 32-byte string representation of the chain code
+        chain    This is a 32-byte str representation of the chain code
 
         depth    Child depth; parent increments its own by one when assigning this
 

nectargraphenebase/bip38.py

@@ -6,7 +6,6 @@ from binascii import hexlify, unhexlify
 
 from .account import PrivateKey
 from .base58 import Base58, base58decode
-from .py23 import py23_bytes, text_type
 
 log = logging.getLogger(__name__)
 
@@ -62,16 +61,16 @@ def encrypt(privkey, passphrase):
 
     privkeyhex = repr(privkey)  # hex
     addr = format(privkey.bitcoin.address, "BTC")
-    a = py23_bytes(addr, "ascii")
+    a = bytes(addr, "ascii")
     salt = hashlib.sha256(hashlib.sha256(a).digest()).digest()[0:4]
     if sys.version < "3":
-        if isinstance(passphrase, text_type):
+        if isinstance(passphrase, str):
             passphrase = passphrase.encode("utf-8")
 
     if SCRYPT_MODULE == "scrypt":
         key = scrypt.hash(passphrase, salt, 16384, 8, 8)
     elif SCRYPT_MODULE == "pylibscrypt":
-        key = scrypt.scrypt(py23_bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
+        key = scrypt.scrypt(bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
     else:
         raise ValueError("No scrypt module loaded")
     (derived_half1, derived_half2) = (key[:32], key[32:])
@@ -106,12 +105,12 @@ def decrypt(encrypted_privkey, passphrase):
     salt = d[0:4]
     d = d[4:-4]
     if sys.version < "3":
-        if isinstance(passphrase, text_type):
+        if isinstance(passphrase, str):
             passphrase = passphrase.encode("utf-8")
     if SCRYPT_MODULE == "scrypt":
         key = scrypt.hash(passphrase, salt, 16384, 8, 8)
     elif SCRYPT_MODULE == "pylibscrypt":
-        key = scrypt.scrypt(py23_bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
+        key = scrypt.scrypt(bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
     else:
         raise ValueError("No scrypt module loaded")
     derivedhalf1 = key[0:32]
@@ -127,7 +126,7 @@ def decrypt(encrypted_privkey, passphrase):
     """ Verify Salt """
     privkey = PrivateKey(format(wif, "wif"))
     addr = format(privkey.bitcoin.address, "BTC")
-    a = py23_bytes(addr, "ascii")
+    a = bytes(addr, "ascii")
     saltverify = hashlib.sha256(hashlib.sha256(a).digest()).digest()[0:4]
     if saltverify != salt:
         raise SaltException("checksum verification failed! Password may be incorrect.")

nectargraphenebase/ecdsasig.py

@@ -8,7 +8,6 @@ from binascii import hexlify
 import ecdsa
 
 from .account import PrivateKey, PublicKey
-from .py23 import bytes_types, py23_bytes
 
 log = logging.getLogger(__name__)
 
@@ -22,7 +21,7 @@ if not SECP256K1_MODULE:
 
         SECP256K1_MODULE = "secp256k1"
         SECP256K1_AVAILABLE = True
-    except:
+    except Exception:
         try:
             import secp256k1
 
@@ -31,26 +30,22 @@ if not SECP256K1_MODULE:
         except ImportError:
             try:
                 import cryptography
-
-                SECP256K1_MODULE = "cryptography"
-                CRYPTOGRAPHY_AVAILABLE = True
             except ImportError:
                 SECP256K1_MODULE = "ecdsa"
+            else:
+                SECP256K1_MODULE = "cryptography"
+                CRYPTOGRAPHY_AVAILABLE = True
 
-    try:
-        from cryptography.exceptions import InvalidSignature
-        from cryptography.hazmat.backends import default_backend
-        from cryptography.hazmat.primitives import hashes
-        from cryptography.hazmat.primitives.asymmetric import ec
-        from cryptography.hazmat.primitives.asymmetric.utils import (
-            decode_dss_signature,
-            encode_dss_signature,
-        )
-
-        CRYPTOGRAPHY_AVAILABLE = True
-    except ImportError:
-        CRYPTOGRAPHY_AVAILABLE = False
-        log.debug("Cryptography not available")
+try:
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.asymmetric import ec
+    from cryptography.hazmat.primitives.asymmetric.utils import (
+        decode_dss_signature,
+        encode_dss_signature,
+    )
+except ImportError:
+    pass
 
 log.debug("Using SECP256K1 module: %s" % SECP256K1_MODULE)
 
@@ -76,7 +71,7 @@ def compressedPubkey(pk):
         x = p.x()
         y = p.y()
     x_str = ecdsa.util.number_to_string(x, order)
-    return py23_bytes(chr(2 + (y & 1)), "ascii") + x_str
+    return bytes(chr(2 + (y & 1)), "ascii") + x_str
 
 
 def recover_public_key(digest, signature, i, message=None):
@@ -103,20 +98,20 @@ def recover_public_key(digest, signature, i, message=None):
     Q = ecdsa.numbertheory.inverse_mod(r, order) * (s * R + (-e % order) * G)
 
     if SECP256K1_MODULE == "cryptography" and message is not None:
-        if not isinstance(message, bytes_types):
-            message = py23_bytes(message, "utf-8")
+        if not isinstance(message, bytes):
+            message = bytes(message, "utf-8")
         sigder = encode_dss_signature(r, s)
         try:
             Q_point = Q.to_affine()
             public_key = ec.EllipticCurvePublicNumbers(
                 Q_point.x(), Q_point.y(), ec.SECP256K1()
             ).public_key(default_backend())
-        except:
+        except Exception:
             try:
                 public_key = ec.EllipticCurvePublicNumbers(
                     Q._Point__x, Q._Point__y, ec.SECP256K1()
                 ).public_key(default_backend())
-            except:
+            except Exception:
                 Q_point = Q.to_affine()
                 public_key = ec.EllipticCurvePublicNumbers(
                     int(Q_point.x()), int(Q_point.y()), ec.SECP256K1()
@@ -136,8 +131,8 @@ def recoverPubkeyParameter(message, digest, signature, pubkey):
     """Use to derive a number that allows to easily recover the
     public key from the signature
     """
-    if not isinstance(message, bytes_types):
-        message = py23_bytes(message, "utf-8")
+    if not isinstance(message, bytes):
+        message = bytes(message, "utf-8")
     for i in range(0, 4):
         if SECP256K1_MODULE == "secp256k1":
             sig = pubkey.ecdsa_recoverable_deserialize(signature, i)
@@ -155,7 +150,7 @@ def recoverPubkeyParameter(message, digest, signature, pubkey):
             p_comp = hexlify(compressedPubkey(p))
             p_string = hexlify(p.to_string())
             if isinstance(pubkey, PublicKey):
-                pubkey_string = py23_bytes(repr(pubkey), "latin")
+                pubkey_string = bytes(repr(pubkey), "latin")
             else:  # pragma: no cover
                 pubkey_string = hexlify(pubkey.to_string())
             if p_string == pubkey_string or p_comp == pubkey_string:
@@ -169,13 +164,13 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
     :param str wif: Private key in
     """
 
-    if not isinstance(message, bytes_types):
-        message = py23_bytes(message, "utf-8")
+    if not isinstance(message, bytes):
+        message = bytes(message, "utf-8")
 
     digest = hashfn(message).digest()
     priv_key = PrivateKey(wif)
     if SECP256K1_MODULE == "secp256k1":
-        p = py23_bytes(priv_key)
+        p = bytes(priv_key)
         ndata = secp256k1.ffi.new("const int *ndata")
         ndata[0] = 0
         while True:
@@ -220,7 +215,7 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
                 break
     else:  # pragma: no branch  # pragma: no cover
         cnt = 0
-        p = py23_bytes(priv_key)
+        p = bytes(priv_key)
         sk = ecdsa.SigningKey.from_string(p, curve=ecdsa.SECP256k1)
         while 1:
             cnt += 1
@@ -270,13 +265,13 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
 
 
 def verify_message(message, signature, hashfn=hashlib.sha256, recover_parameter=None):
-    if not isinstance(message, bytes_types):
-        message = py23_bytes(message, "utf-8")
-    if not isinstance(signature, bytes_types):
-        signature = py23_bytes(signature, "utf-8")
-    if not isinstance(message, bytes_types):
+    if not isinstance(message, bytes):
+        message = bytes(message, "utf-8")
+    if not isinstance(signature, bytes):
+        signature = bytes(signature, "utf-8")
+    if not isinstance(message, bytes):
         raise AssertionError()
-    if not isinstance(signature, bytes_types):
+    if not isinstance(signature, bytes):
         raise AssertionError()
     digest = hashfn(message).digest()
     sig = signature[1:]