hive-nectar 0.0.6__py3-none-any.whl → 0.0.9__py3-none-any.whl

nectarapi/__init__.py

@@ -3,6 +3,7 @@
 from .version import version as __version__
 
 __all__ = [
+    "__version__",
     "noderpc",
     "exceptions",
     "rpcutils",

nectarapi/exceptions.py

@@ -19,37 +19,43 @@ def decodeRPCErrorMsg(e):
         return str(e)
 
 
-class UnauthorizedError(Exception):
+class NectarApiException(Exception):
+    """NectarApiException base Exception."""
+
+    pass
+
+
+class UnauthorizedError(NectarApiException):
     """UnauthorizedError Exception."""
 
     pass
 
 
-class RPCConnection(Exception):
+class RPCConnection(NectarApiException):
     """RPCConnection Exception."""
 
     pass
 
 
-class RPCError(Exception):
+class RPCError(NectarApiException):
     """RPCError Exception."""
 
     pass
 
 
-class RPCErrorDoRetry(Exception):
+class RPCErrorDoRetry(NectarApiException):
     """RPCErrorDoRetry Exception."""
 
     pass
 
 
-class NumRetriesReached(Exception):
+class NumRetriesReached(NectarApiException):
     """NumRetriesReached Exception."""
 
     pass
 
 
-class CallRetriesReached(Exception):
+class CallRetriesReached(NectarApiException):
     """CallRetriesReached Exception. Only for internal use"""
 
     pass
@@ -91,33 +97,33 @@ class FilteredItemNotFound(RPCError):
     pass
 
 
-class InvalidEndpointUrl(Exception):
+class InvalidEndpointUrl(NectarApiException):
     pass
 
 
-class InvalidParameters(Exception):
+class InvalidParameters(NectarApiException):
     pass
 
 
-class SupportedByHivemind(Exception):
+class SupportedByHivemind(NectarApiException):
     pass
 
 
-class UnnecessarySignatureDetected(Exception):
+class UnnecessarySignatureDetected(NectarApiException):
     pass
 
 
-class WorkingNodeMissing(Exception):
+class WorkingNodeMissing(NectarApiException):
     pass
 
 
-class TimeoutException(Exception):
+class TimeoutException(NectarApiException):
     pass
 
 
-class VotedBeforeWaitTimeReached(Exception):
+class VotedBeforeWaitTimeReached(NectarApiException):
     pass
 
 
-class UnknownTransaction(Exception):
+class UnknownTransaction(NectarApiException):
     pass

nectarapi/version.py

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

nectarbase/__init__.py

@@ -3,6 +3,7 @@
 from .version import version as __version__
 
 __all__ = [
+    "__version__",
     "memo",
     "objects",
     "objecttypes",

nectarbase/ledgertransactions.py

@@ -3,7 +3,6 @@ import logging
 
 from nectargraphenebase.account import PublicKey
 from nectargraphenebase.chains import known_chains
-from nectargraphenebase.py23 import py23_bytes
 from nectargraphenebase.types import (
     Array,
     Signature,
@@ -54,7 +53,7 @@ class Ledger_Transaction(GrapheneUnsigned_Transaction):
         dongle = getDongle(True)
         apdu_list = self.build_apdu(path, chain)
         for apdu in apdu_list:
-            result = dongle.exchange(py23_bytes(apdu))
+            result = dongle.exchange(bytes(apdu))
         dongle.close()
         sigs = []
         signature = result
@@ -67,7 +66,7 @@ class Ledger_Transaction(GrapheneUnsigned_Transaction):
 
         dongle = getDongle(True)
         apdu = self.build_apdu_pubkey(path, request_screen_approval)
-        result = dongle.exchange(py23_bytes(apdu))
+        result = dongle.exchange(bytes(apdu))
         dongle.close()
         offset = 1 + result[0]
         address = result[offset + 1 : offset + 1 + result[offset]]

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.6"
+version = "0.0.9"

nectargraphenebase/__init__.py

@@ -10,6 +10,7 @@ from .version import version as __version__
 # from . import dictionary as BrainKeyDictionary
 
 __all__ = [
+    "__version__",
     "account",
     "aes",
     "base58",
@@ -23,5 +24,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.")