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

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:]

nectargraphenebase/objects.py

@@ -4,13 +4,12 @@ import json
 from nectargraphenebase.types import Id, JsonObj, Optional, String
 
 from .operationids import operations
-from .py23 import integer_types, py23_bytes, string_types
 
 
 class Operation(object):
     def __init__(self, op):
         if isinstance(op, list) and len(op) == 2:
-            if isinstance(op[0], integer_types):
+            if isinstance(op[0], int):
                 self.opId = op[0]
                 name = self.getOperationNameForId(self.opId)
             else:
@@ -61,7 +60,7 @@ class Operation(object):
         return class_
 
     def __bytes__(self):
-        return py23_bytes(Id(self.opId)) + py23_bytes(self.op)
+        return bytes(Id(self.opId)) + bytes(self.op)
 
     def __str__(self):
         return json.dumps([self.opId, self.op.toJson()])
@@ -83,13 +82,13 @@ class GrapheneObject(object):
 
     def __bytes__(self):
         if self.data is None:
-            return py23_bytes()
+            return bytes()
         b = b""
         for name, value in list(self.data.items()):
-            if isinstance(value, string_types):
-                b += py23_bytes(value, "utf-8")
+            if isinstance(value, str):
+                b += bytes(value, "utf-8")
             else:
-                b += py23_bytes(value)
+                b += bytes(value)
         return b
 
     def __json__(self):

nectargraphenebase/operations.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+from collections import OrderedDict
+
 from .objects import GrapheneObject, isArgsThisClass
 from .types import (
     Set,

nectargraphenebase/signedtransactions.py

@@ -6,8 +6,6 @@ from collections import OrderedDict
 
 import ecdsa
 
-from nectargraphenebase.py23 import py23_bytes
-
 from .account import PublicKey
 from .chains import known_chains
 from .ecdsasig import sign_message, verify_message
@@ -48,9 +46,12 @@ class Signed_Transaction(GrapheneObject):
             if "signatures" not in kwargs:
                 kwargs["signatures"] = Array([])
             else:
-                kwargs["signatures"] = Array(
-                    [Signature(unhexlify(a)) for a in kwargs["signatures"]]
-                )
+                # Defensive: if a string, wrap in a list and log warning
+                sigs = kwargs["signatures"]
+                if isinstance(sigs, str):
+                    log.warning("signatures was a string, converting to list to avoid type errors.")
+                    sigs = [sigs]
+                kwargs["signatures"] = Array([Signature(unhexlify(a)) for a in sigs])
 
             if "operations" in kwargs:
                 opklass = self.getOperationKlass()
@@ -83,7 +84,7 @@ class Signed_Transaction(GrapheneObject):
         self.data.pop("signatures", None)
 
         # Generage Hash of the seriliazed version
-        h = hashlib.sha256(py23_bytes(self)).digest()
+        h = hashlib.sha256(bytes(self)).digest()
 
         # recover signatures
         self.data["signatures"] = sigs
@@ -133,7 +134,7 @@ class Signed_Transaction(GrapheneObject):
         # Get message to sign
         #   bytes(self) will give the wire formated data according to
         #   GrapheneObject and the data given in __init__()
-        self.message = unhexlify(self.chainid) + py23_bytes(self)
+        self.message = unhexlify(self.chainid) + bytes(self)
         self.digest = hashlib.sha256(self.message).digest()
 
         # restore signatures
@@ -150,13 +151,13 @@ class Signed_Transaction(GrapheneObject):
 
         for signature in signatures:
             if recover_parameter:
-                p = verify_message(self.message, py23_bytes(signature))
+                p = verify_message(self.message, bytes(signature))
             else:
                 p = None
             if p is None:
                 for i in range(4):
                     try:
-                        p = verify_message(self.message, py23_bytes(signature), recover_parameter=i)
+                        p = verify_message(self.message, bytes(signature), recover_parameter=i)
                         phex = hexlify(p).decode("ascii")
                         pubKeysFound.append(phex)
                     except Exception:

nectargraphenebase/types.py

@@ -1,14 +1,11 @@
 # -*- coding: utf-8 -*-
 import json
 import struct
-import sys
 import time
 from binascii import hexlify, unhexlify
 from calendar import timegm
 from datetime import datetime
 
-from .py23 import py23_bytes
-
 timeformat = "%Y-%m-%dT%H:%M:%S%Z"
 
 
@@ -247,7 +244,7 @@ class Array(object):
 
     def __bytes__(self):
         """Returns bytes representation."""
-        return py23_bytes(self.length) + b"".join([py23_bytes(a) for a in self.data])
+        return bytes(self.length) + b"".join([bytes(a) for a in self.data])
 
     def __str__(self):
         """Returns data as string."""
@@ -271,10 +268,8 @@ class PointInTime(object):
         """Returns bytes representation."""
         if isinstance(self.data, datetime):
             unixtime = timegm(self.data.timetuple())
-        elif sys.version > "3":
-            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat))
         else:
-            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat.encode("utf-8")))
+            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat))
         if unixtime < 0:
             return struct.pack("<i", unixtime)
         return struct.pack("<I", unixtime)
@@ -331,22 +326,17 @@ class Optional(object):
     def __bytes__(self):
         """Returns data as bytes."""
         if not self.data:
-            return py23_bytes(Bool(0))
+            return bytes(Bool(0))
         else:
-            return (
-                py23_bytes(Bool(1)) + py23_bytes(self.data)
-                if py23_bytes(self.data)
-                else py23_bytes(Bool(0))
-            )
+            return bytes(Bool(1)) + bytes(self.data)
 
     def __str__(self):
         """Returns data as string."""
         return str(self.data)
 
     def isempty(self):
-        if not self.data:
-            return True
-        return not bool(py23_bytes(self.data))
+        """Returns True if data is empty, False otherwise."""
+        return not self.data
 
 
 class Static_variant(object):
@@ -359,7 +349,7 @@ class Static_variant(object):
 
     def __bytes__(self):
         """Returns bytes representation."""
-        return varint(self.type_id) + py23_bytes(self.data)
+        return varint(self.type_id) + bytes(self.data)
 
     def __str__(self):
         """Returns data as string."""
@@ -378,7 +368,7 @@ class Map(object):
         b = b""
         b += varint(len(self.data))
         for e in self.data:
-            b += py23_bytes(e[0]) + py23_bytes(e[1])
+            b += bytes(e[0]) + bytes(e[1])
         return b
 
     def __str__(self):
@@ -395,7 +385,7 @@ class Id(object):
 
     def __bytes__(self):
         """Returns bytes representation."""
-        return py23_bytes(self.data)
+        return bytes(self.data)
 
     def __str__(self):
         """Returns data as string."""

nectargraphenebase/unsignedtransactions.py

@@ -8,12 +8,9 @@ from collections import OrderedDict
 import ecdsa
 from asn1crypto.core import OctetString
 
-from nectargraphenebase.py23 import py23_bytes
-
 from .bip32 import parse_path
 from .chains import known_chains
 from .objects import Operation, isArgsThisClass
-from .py23 import py23_chr, string_types
 from .types import (
     Array,
     JsonObj,
@@ -46,22 +43,22 @@ class GrapheneObjectASN1(object):
 
     def __bytes__(self):
         if self.data is None:
-            return py23_bytes()
+            return bytes()
         b = b""
         output = b""
         for name, value in list(self.data.items()):
             if name == "operations":
                 for operation in value:
-                    if isinstance(value, string_types):
-                        b = py23_bytes(operation, "utf-8")
+                    if isinstance(value, str):
+                        b = bytes(operation, "utf-8")
                     else:
-                        b = py23_bytes(operation)
+                        b = bytes(operation)
                     output += OctetString(b).dump()
             elif name != "signatures":
-                if isinstance(value, string_types):
-                    b = py23_bytes(value, "utf-8")
+                if isinstance(value, str):
+                    b = bytes(value, "utf-8")
                 else:
-                    b = py23_bytes(value)
+                    b = bytes(value)
                 output += OctetString(b).dump()
         return output
 
@@ -123,7 +120,7 @@ class Unsigned_Transaction(GrapheneObjectASN1):
                 operations_count = len(kwargs["operations"])
                 # opklass = self.getOperationKlass()
                 # if all([not isinstance(a, opklass) for a in kwargs["operations"]]):
-                #    kwargs['operations'] = Array([opklass(a, prefix=prefix) for a in kwargs["operations"]])
+                #    kwargs['operations'] = Array([opklass(a, ) for a in kwargs["operations"]])
                 # else:
                 #    kwargs['operations'] = (kwargs["operations"])
 
@@ -150,7 +147,7 @@ class Unsigned_Transaction(GrapheneObjectASN1):
         self.data.pop("signatures", None)
 
         # Generage Hash of the seriliazed version
-        h = hashlib.sha256(py23_bytes(self)).digest()
+        h = hashlib.sha256(bytes(self)).digest()
 
         # recover signatures
         self.data["signatures"] = sigs
@@ -204,16 +201,16 @@ class Unsigned_Transaction(GrapheneObjectASN1):
         for name, value in list(self.data.items()):
             if name == "operations":
                 for operation in value:
-                    if isinstance(value, string_types):
-                        b = py23_bytes(operation, "utf-8")
+                    if isinstance(value, str):
+                        b = bytes(operation, "utf-8")
                     else:
-                        b = py23_bytes(operation)
+                        b = bytes(operation)
                     self.message += OctetString(b).dump()
             elif name != "signatures":
-                if isinstance(value, string_types):
-                    b = py23_bytes(value, "utf-8")
+                if isinstance(value, str):
+                    b = bytes(value, "utf-8")
                 else:
-                    b = py23_bytes(value)
+                    b = bytes(value)
                 self.message += OctetString(b).dump()
 
         self.digest = hashlib.sha256(self.message).digest()
@@ -251,16 +248,12 @@ class Unsigned_Transaction(GrapheneObjectASN1):
             if first:
                 total_size = int(len(path)) + 1 + len(chunk)
                 apdu = (
-                    unhexlify("d4040000")
-                    + py23_chr(total_size)
-                    + py23_chr(path_size)
-                    + path
-                    + chunk
+                    unhexlify("d4040000") + bytes([total_size]) + bytes([path_size]) + path + chunk
                 )
                 first = False
             else:
                 total_size = len(chunk)
-                apdu = unhexlify("d4048000") + py23_chr(total_size) + chunk
+                apdu = unhexlify("d4048000") + bytes([total_size]) + chunk
             result.append(apdu)
             offset += len(chunk)
         return result
@@ -270,14 +263,14 @@ class Unsigned_Transaction(GrapheneObjectASN1):
         if not request_screen_approval:
             return (
                 unhexlify("d4020001")
-                + py23_chr(int(len(path)) + 1)
-                + py23_chr(int(len(path) / 4))
+                + bytes([int(len(path)) + 1])
+                + bytes([int(len(path) / 4)])
                 + path
             )
         else:
             return (
                 unhexlify("d4020101")
-                + py23_chr(int(len(path)) + 1)
-                + py23_chr(int(len(path) / 4))
+                + bytes([int(len(path)) + 1])
+                + bytes([int(len(path) / 4)])
                 + path
             )

nectargraphenebase/version.py

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

nectarstorage/__init__.py

@@ -15,7 +15,27 @@ from .base import (
 )
 from .sqlite import SQLiteCommon, SQLiteFile
 
-__all__ = ["interfaces", "masterpassword", "base", "sqlite", "ram"]
+__all__ = [
+    # submodules
+    "interfaces",
+    "masterpassword",
+    "base",
+    "sqlite",
+    "ram",
+    # store classes re-exported for convenience
+    "InRamConfigurationStore",
+    "InRamEncryptedKeyStore",
+    "InRamEncryptedTokenStore",
+    "InRamPlainKeyStore",
+    "InRamPlainTokenStore",
+    "SqliteConfigurationStore",
+    "SqliteEncryptedKeyStore",
+    "SqliteEncryptedTokenStore",
+    "SqlitePlainKeyStore",
+    "SqlitePlainTokenStore",
+    "SQLiteCommon",
+    "SQLiteFile",
+]
 
 
 def get_default_config_store(*args, **kwargs):

nectarstorage/masterpassword.py

@@ -8,7 +8,6 @@ from binascii import hexlify
 
 from nectargraphenebase import bip38
 from nectargraphenebase.aes import AESCipher
-from nectargraphenebase.py23 import py23_bytes
 
 from .exceptions import WalletLocked, WrongMasterPasswordException
 
@@ -192,7 +191,7 @@ class MasterPassword(object):
 
     def deriveChecksum(self, s):
         """Derive the checksum"""
-        checksum = hashlib.sha256(py23_bytes(s, "ascii")).hexdigest()
+        checksum = hashlib.sha256(bytes(s, "ascii")).hexdigest()
         return checksum[:4]
 
     def encrypt_text(self, txt):
@@ -216,7 +215,7 @@ class MasterPassword(object):
         checksum, encrypted_text = enctxt.split("$")
         try:
             decrypted_text = aes.decrypt(encrypted_text)
-        except:
+        except Exception:
             raise WrongMasterPasswordException
         if checksum != self.deriveChecksum(decrypted_text):
             raise WrongMasterPasswordException

nectarstorage/sqlite.py

@@ -5,7 +5,7 @@ import os
 import shutil
 import sqlite3
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 
 from appdirs import user_data_dir
 

hive_nectar-0.0.6.dist-info/RECORD

@@ -1,92 +0,0 @@
-nectar/__init__.py,sha256=YH9ietjJFhFxTPwQ3K9iw8VJZ__CNK5QTQeGcw1iKzk,503
-nectar/account.py,sha256=ZstMVwgllIKoOSnTmSpL3o2okrkL3-qqTwmwZyJQxyI,172273
-nectar/amount.py,sha256=Zpk-BAoRt1QjwO32CIBmXpCBIhyU1qHm_skYPjfboXg,18235
-nectar/asciichart.py,sha256=DwPyZAqne6o9L_PPRtlw6Xj0QdOZ-aId1lpOnmbyc6Q,8828
-nectar/asset.py,sha256=spGsJmlVQeZ6-oYhcwmQKsI3gpGmrpCzimYO1Qv4MtA,2725
-nectar/block.py,sha256=7nXVaYt8_tu9TJD6Zcr4Vo3owK8Rv8VKueWygawml3U,16064
-nectar/blockchain.py,sha256=FflzDKS3ByWRnYiOOE94la6ZgJ0QHihnOpqD9qRi6_0,49159
-nectar/blockchaininstance.py,sha256=mrHuhHsR7h-becNe_bE8WieFqMFyz49s-LecmC_k134,93119
-nectar/blockchainobject.py,sha256=ZlWeOWGMoHyATgw20YfPV47OYlwuOpO75hmf0c9IC_4,7095
-nectar/blurt.py,sha256=cZoUyAdr_HdUTm8K3N-PyaFYfpBL_WmomFWeWTHbeIA,23070
-nectar/cli.py,sha256=jYi_EGZKeML7fvVX3g59uqWsUPL2e72NkxM4qFFrjLM,227475
-nectar/comment.py,sha256=Hqj1TL9vKCWmDnBikVG8yCl7hgAwPBfqN_pkDsjtaxo,46791
-nectar/community.py,sha256=XyxIfdpIWart70MM2ojlZTfbKcRYr6qxGcWtEQNHfuI,17990
-nectar/constants.py,sha256=lrspBwCz9BE0YZY10DMS98oPwwxgmI0LzFdlQ7v53Ig,4974
-nectar/conveyor.py,sha256=dpvaVLaR48Tn56fkCUl5MoDQDcR3eLcrIKYm6ctZkRM,11265
-nectar/discussions.py,sha256=n-4GnYvnDc5AwFdUHSA9wTfdCmLWHb9h06U4vWq05q4,66439
-nectar/exceptions.py,sha256=fTwnJo0VxKrCLV6okNSkInyQLHOj0uaoBD8syq1h9Fw,2639
-nectar/hive.py,sha256=ota3Ttp_K2Eyy34UyWnAdYhI8eEX1uS-CvzalaFqSvc,22254
-nectar/hivesigner.py,sha256=olHHuLtBrjN8PgXfGTeMNzshwi7WtzdcrLuyYLBeIhk,13998
-nectar/imageuploader.py,sha256=kQd-IKrF9K4D5F-vnm8iRC3AuJa-fpozTpKUkKSr0ig,2722
-nectar/instance.py,sha256=oUAycW1q5ynM3M4O9a0drgY7e8UBExTj69aMxrOjxwg,3905
-nectar/market.py,sha256=mlKKsq6DQ4WCLaqNnuuwbJM4qUiejy5pGdXIPKK2Sug,41972
-nectar/memo.py,sha256=lTIuPrX-kPynOa-9q6kJHRzb9BfJjSf0kdpipwEXnY8,17777
-nectar/message.py,sha256=lVGaydsxh8oMTS90khho3DtqxhzgIrt4NmjxwyP0X3k,13019
-nectar/nodelist.py,sha256=3OPrfVVaI6Wza-yuqDfryoCgCA4dDUL64x6wwYqPSFA,15219
-nectar/price.py,sha256=WV1ix2cuWHPIFq4cFJZD37ud-9BDBpvlv4BznI_cGTI,21270
-nectar/profile.py,sha256=t-pqC2DZxzvTV2XLU6iZWT1NdHuk77A_iiisbA0QIOM,1921
-nectar/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectar/rc.py,sha256=BAc88X1mObL2FQSm4ABhBsRfWDBHkee0SCigZ6QlA2c,12825
-nectar/snapshot.py,sha256=_5hsrmJDpPoWTYtQGZ2grMMuuGBInOGS0ip9gv5-RJo,31696
-nectar/steem.py,sha256=JwfO-dp7HT3mVEZVunHNp87gFbdO8e1tcpXQs_MygJ8,23916
-nectar/storage.py,sha256=yYsWc12fOUKEAkSn5wKGS-wSvsac3sMVn6uzLu_pn8c,1855
-nectar/transactionbuilder.py,sha256=j5PD3Wm_w9gHnKJ1Ug3sxz3RWPclWt-MQIO5ox027X8,25443
-nectar/utils.py,sha256=OGeLuO_nYDAvcX-onrm4xjn1L0binq8Glelgg6RdlSo,18882
-nectar/version.py,sha256=x7maU-a8H7SAAs06_OW-iZAEZ1HvGWVdSaQbjWOSVBQ,76
-nectar/vote.py,sha256=sO_ukJMEcUO_WI-D2EwbAiiRLApRQ1fyiwyX7YSAiOk,20222
-nectar/wallet.py,sha256=pgbiLJbwXKMiR7EOtuVFee6s3nAdpILHVQ5iPNy7zhs,16222
-nectar/witness.py,sha256=88XYjhTRNhyu9hfIG0sm3Pg1hC9eooo3HhW5EhcaYps,23600
-nectarapi/__init__.py,sha256=c0J2Z-lHOvkSch9bZS3LVQZjKku2XxnYMZToq7OAkfI,157
-nectarapi/exceptions.py,sha256=FnS4-ywWDxEAtV65Hd-4XxAV7j1wRgtQRLIvIGxA0Xs,1824
-nectarapi/graphenerpc.py,sha256=7woRA4CmuwqYrJU9E4LV3UdxaANHzIrKuWZPaxTcJnw,22642
-nectarapi/node.py,sha256=mjK-fMFJ2icDaOUBoiUuDU-beo3aQK0HGwt0l0pC0YQ,5456
-nectarapi/noderpc.py,sha256=FxJz1KbjU6FbNdyp7ovOSZ8TbmD_xqQclKjeBP42Jls,10093
-nectarapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectarapi/rpcutils.py,sha256=0nKCrEeNHFSEU3AjaOGNh-2pjc8qw4mRA9lCrBkP1FQ,2910
-nectarapi/version.py,sha256=x7maU-a8H7SAAs06_OW-iZAEZ1HvGWVdSaQbjWOSVBQ,76
-nectarbase/__init__.py,sha256=U18vyJDvtsto3gHN9Fp3DHlcPd954sG06duHc72pNjs,234
-nectarbase/ledgertransactions.py,sha256=97WXhNhcjNDf_XjXDD08lBMzYmvHC63oZMLRQqVNvWY,2545
-nectarbase/memo.py,sha256=_-y9bxGr1DyEaD2-twVJ5Y-1ttFD-VJLyVAYzlT2ijw,7570
-nectarbase/objects.py,sha256=ukBsUft2actWwlka2prwZkZtTKwLL0HgJfQtAvZfLIs,14894
-nectarbase/objecttypes.py,sha256=zrKBFwoUJXvWDSn8RugWioKqf7TS7dY0EEXVAZv_-K0,690
-nectarbase/operationids.py,sha256=wpKltPFlInpueyvLl3XCI2fjP9ziIs4MStoIj2mbPfQ,3645
-nectarbase/operations.py,sha256=K-ypT0KMcRPjcoOuYyUhpRaRUv5FtAhfdc7kSqbFyCs,47628
-nectarbase/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectarbase/signedtransactions.py,sha256=r-MRnEQDnx6U6XFPcM3hPXiDZvU6sQVx4Vv_0nZF7fs,1792
-nectarbase/transactions.py,sha256=D7TK4Pkxr1N7p0Yh2bxvdXpOuEYpLl2tWK84Pj_93c0,319
-nectarbase/version.py,sha256=x7maU-a8H7SAAs06_OW-iZAEZ1HvGWVdSaQbjWOSVBQ,76
-nectargrapheneapi/__init__.py,sha256=_Gxdt_qaQQwwYABHEFBuf4tMh93ItIa3HPBH9nk1PTw,151
-nectargrapheneapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectargraphenebase/__init__.py,sha256=PzB_0qiWfqJku5vKQs0CpkVeipPmZ33Fpc1px4VCV-Q,570
-nectargraphenebase/account.py,sha256=pi3TFr6_CwGajdwDuAqlRGElmLhjBXlxC7mMOpc0vUU,29789
-nectargraphenebase/aes.py,sha256=BywHJR8F7n2IBXhBmXqyc61DlVXcJ_QIE9qkubFdX2M,1578
-nectargraphenebase/base58.py,sha256=NHvj7O6E94nX4BVK78u9IxAR8-QMIsasj6fj6yidm9Q,5552
-nectargraphenebase/bip32.py,sha256=o2PZ37R1fZAg4YHPzvmCjp9qHNcC9Zkju_C1NRNUNbM,16274
-nectargraphenebase/bip38.py,sha256=qSgH2_Y6kdcXLNI67qMmkjikI6aT4YET4R--GHT170Q,4530
-nectargraphenebase/chains.py,sha256=JhaqY8qZaK-6OYf72RLVNxJtrc6yZtYxJm8p9U-i338,6185
-nectargraphenebase/dictionary.py,sha256=Fooynl3XWE9ALy31jsVNb9CEHZh5N8TeJUAZJvqslnY,360748
-nectargraphenebase/ecdsasig.py,sha256=BIaKNg4-_9ijo3xjbLfEmN0amIIVaK_yG5haUUevcEQ,12425
-nectargraphenebase/objects.py,sha256=tYBvmAf7VU-06uDccRpFAQORGuOEtQd_jOqS3muK7zo,3998
-nectargraphenebase/objecttypes.py,sha256=8YkRyxtd1hNZ06XvyHBRA5PatVeTd8XCFQmW_2p8MGk,160
-nectargraphenebase/operationids.py,sha256=TLXB8FovmDwC39PNAR8OaW-NWyo1gFH0zE4ibShcMiI,65
-nectargraphenebase/operations.py,sha256=fPTQ98sUtQRClAakBKPCGZjG0iIAAJqM5Y72Ip_HWWI,653
-nectargraphenebase/prefix.py,sha256=tpX2_uz5lPveUoGbmXC4zsrG-5QsaVbIGIFPWJvYRbg,280
-nectargraphenebase/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectargraphenebase/py23.py,sha256=aI1MAQ74DngxkjdpRlWEspmB1HNTQcpj3uHKo0b7rsM,784
-nectargraphenebase/signedtransactions.py,sha256=y5tq9ijO_EXUpn77cHgqx55RcsY0Jr-lwj_r_0w7OHI,6947
-nectargraphenebase/types.py,sha256=OZGVxgOoNPLiElNyDluUpmXNyREGzCEekZwq5uwPfGE,9771
-nectargraphenebase/unsignedtransactions.py,sha256=HwhbWkWS1mYCJWKMsUI18PogEmZ5sVTWLPwolvM6ZR0,9522
-nectargraphenebase/version.py,sha256=x7maU-a8H7SAAs06_OW-iZAEZ1HvGWVdSaQbjWOSVBQ,76
-nectarstorage/__init__.py,sha256=AQXmR8clT9bO9SnIM8QEr5S8ZOpbKuG_BnBsDmGvec0,1347
-nectarstorage/base.py,sha256=h7Oca1_RaJw39P1I_xXRKup016pS8zCLOs3e4IHKKdE,9734
-nectarstorage/exceptions.py,sha256=0erk_d0Ejia9td_Ke7XFBl17H1BxbM42gFpkej8EbV0,421
-nectarstorage/interfaces.py,sha256=WK2YR2mKUk1Qts50ZYLd407gECywA02A8iWr_p0KfCw,6786
-nectarstorage/masterpassword.py,sha256=nyG90LeHeqEjXVbRT36gAWGe-MxyKGCfQ8SqvytK1no,8696
-nectarstorage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectarstorage/ram.py,sha256=Cy6JbMrlgcEG673_KqfyaofhAdJR-luRKTedj3qTZEE,1034
-nectarstorage/sqlite.py,sha256=fkkDgi1lPv7lRo5wEAe4BzSVd2kDBGss3vCDYeNzDCs,10625
-hive_nectar-0.0.6.dist-info/METADATA,sha256=pTDha7Q-J-O4yAJMXFs2FRPZnq8yH6xvMfGgZFfRI8w,6062
-hive_nectar-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hive_nectar-0.0.6.dist-info/entry_points.txt,sha256=DbqiJb5fFpQvGZ0ojvc2w3dXZitTg6FPz09CobKq4m8,47
-hive_nectar-0.0.6.dist-info/licenses/LICENSE.txt,sha256=WjJRNR4r7FuLEO2BTBLGa05T7bBecGGgH47NgKsSY0E,1158
-hive_nectar-0.0.6.dist-info/RECORD,,