hive-nectar 0.0.11__py3-none-any.whl → 0.1.0__py3-none-any.whl

nectargraphenebase/ecdsasig.py

@@ -2,55 +2,37 @@
 import hashlib
 import logging
 import struct
-import time
 from binascii import hexlify
 
 import ecdsa
+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 (
+    Prehashed,
+    decode_dss_signature,
+    encode_dss_signature,
+)
 
 from .account import PrivateKey, PublicKey
 
 log = logging.getLogger(__name__)
 
-SECP256K1_MODULE = None
-SECP256K1_AVAILABLE = False
-CRYPTOGRAPHY_AVAILABLE = False
-GMPY2_MODULE = False
-if not SECP256K1_MODULE:
-    try:
-        import secp256k1prp as secp256k1
-
-        SECP256K1_MODULE = "secp256k1"
-        SECP256K1_AVAILABLE = True
-    except Exception:
-        try:
-            import secp256k1
 
-            SECP256K1_MODULE = "secp256k1"
-            SECP256K1_AVAILABLE = True
-        except ImportError:
-            try:
-                import cryptography
-            except ImportError:
-                SECP256K1_MODULE = "ecdsa"
-            else:
-                SECP256K1_MODULE = "cryptography"
-                CRYPTOGRAPHY_AVAILABLE = True
-
-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
+def _is_canonical(sig):
+    """
+    Return True if a 64-byte ECDSA signature (R || S) is in canonical form.
 
-log.debug("Using SECP256K1 module: %s" % SECP256K1_MODULE)
+    A canonical signature here means:
+    - Neither R nor S has its highest bit set (no negative integers when interpreted as signed big-endian).
+    - Neither R nor S has unnecessary leading zero bytes (no extra 0x00 padding before a non-negative highest byte).
 
+    Parameters:
+        sig (bytes or bytearray): 64-byte concatenation of R (32 bytes) followed by S (32 bytes).
 
-def _is_canonical(sig):
+    Returns:
+        bool: True if signature is canonical, False otherwise.
+    """
     sig = bytearray(sig)
     return (
         not (int(sig[0]) & 0x80)
@@ -61,21 +43,62 @@ def _is_canonical(sig):
 
 
 def compressedPubkey(pk):
-    if SECP256K1_MODULE == "cryptography" and not isinstance(pk, ecdsa.keys.VerifyingKey):
+    """
+    Return the 33-byte compressed secp256k1 public key for the given public-key object.
+
+    Accepts either an ecdsa.keys.VerifyingKey or an object exposing public_numbers().x and .y
+    (such as a cryptography EllipticCurvePublicKey). The output is 1 byte (0x02 if y is even,
+    0x03 if y is odd) followed by the 32-byte big-endian X coordinate.
+
+    Parameters:
+        pk: Public-key object (ecdsa.VerifyingKey or object with public_numbers().x and .y).
+
+    Returns:
+        bytes: 33-byte compressed public key (prefix + 32-byte X).
+    """
+    if isinstance(pk, ecdsa.keys.VerifyingKey):
         order = ecdsa.SECP256k1.order
-        x = pk.public_numbers().x
-        y = pk.public_numbers().y
-    else:
-        order = pk.curve.generator.order()
         p = pk.pubkey.point
         x = p.x()
         y = p.y()
+    else:
+        order = ecdsa.SECP256k1.order
+        x = pk.public_numbers().x
+        y = pk.public_numbers().y
     x_str = ecdsa.util.number_to_string(x, order)
     return bytes(chr(2 + (y & 1)), "ascii") + x_str
 
 
 def recover_public_key(digest, signature, i, message=None):
-    """Recover the public key from the the signature"""
+    """
+    Recover the secp256k1 public key from an ECDSA signature and message hash.
+
+    If `message` is provided the function will construct a cryptography EllipticCurvePublicKey
+    from the recovered point and verify the signature against the message; on success it
+    returns that cryptography public key. If `message` is None the function returns an
+    ecdsa.VerifyingKey built from the recovered point after verifying the signature
+    against the provided digest. If verification fails, returns None (when `message` is None)
+    or raises a verification exception (when `message` is provided).
+
+    Parameters:
+        digest (bytes): The message hash (big-endian) used when signing.
+        signature (bytes): 64-byte signature consisting of r||s (raw concatenation).
+        i (int): Recovery identifier (0..3) selecting which of the possible curve points to use.
+        message (bytes or str, optional): Original message to verify against; if a str it is
+            encoded as UTF-8. When provided the function returns a cryptography public key
+            and performs verification using ECDSA-SHA256.
+
+    Returns:
+        cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePublicKey
+            when `message` is provided and verification succeeds;
+        ecdsa.keys.VerifyingKey
+            when `message` is None and digest-based verification succeeds;
+        None
+            when `message` is None and verification fails.
+
+    Raises:
+        cryptography.exceptions.InvalidSignature: If `message` is provided and signature verification fails.
+    """
 
     # See http: //www.secg.org/download/aid-780/sec1-v2.pdf section 4.1.6 primarily
     curve = ecdsa.SECP256k1.curve
@@ -97,7 +120,7 @@ def recover_public_key(digest, signature, i, message=None):
     # 1.6 Compute Q = r^-1(sR - eG)
     Q = ecdsa.numbertheory.inverse_mod(r, order) * (s * R + (-e % order) * G)
 
-    if SECP256K1_MODULE == "cryptography" and message is not None:
+    if message is not None:
         if not isinstance(message, bytes):
             message = bytes(message, "utf-8")
         sigder = encode_dss_signature(r, s)
@@ -128,18 +151,24 @@ def recover_public_key(digest, signature, i, message=None):
 
 
 def recoverPubkeyParameter(message, digest, signature, pubkey):
-    """Use to derive a number that allows to easily recover the
-    public key from the signature
+    """
+    Determine the ECDSA recovery parameter (0–3) that, when used with the given digest and 64-byte signature (R||S), reproduces the provided public key.
+
+    Attempts each recovery index i in 0..3, recovers a candidate public key, and compares its compressed form to the compressed form of the supplied pubkey. If a match is found returns the matching index; otherwise returns None.
+
+    Parameters that need clarification:
+    - message: the original message (will be encoded as UTF-8 if not bytes) and is used when recovering a cryptography public key variant.
+    - digest: the message hash used for recovery.
+    - signature: 64-byte R||S signature (bytes-like).
+    - pubkey: the expected public key to match; may be a cryptography/ec or ecdsa-like public key object.
+
+    Returns:
+        int: matching recovery parameter in 0..3, or None if no match is found.
     """
     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)
-            p = secp256k1.PublicKey(pubkey.ecdsa_recover(message, sig))
-            if p.serialize() == pubkey.serialize():
-                return i
-        elif SECP256K1_MODULE == "cryptography" and not isinstance(pubkey, PublicKey):
+        if not isinstance(pubkey, PublicKey):
             p = recover_public_key(digest, signature, i, message)
             p_comp = hexlify(compressedPubkey(p))
             pubkey_comp = hexlify(compressedPubkey(pubkey))
@@ -159,102 +188,63 @@ def recoverPubkeyParameter(message, digest, signature, pubkey):
 
 
 def sign_message(message, wif, hashfn=hashlib.sha256):
-    """Sign a digest with a wif key
+    """
+    Sign a message using a private key in Wallet Import Format (WIF) and return a compact, canonical ECDSA signature.
+
+    Signs the provided message with secp256k1 ECDSA-SHA256 using the private key derived from the given WIF. The function repeats signing as needed until it produces a canonical 64-byte R||S signature (both R and S encoded as 32 bytes). It also computes the recovery parameter for the signature and encodes it into the first byte of the returned blob.
+
+    Parameters:
+        message (bytes or str): Message to sign. If a str is provided it is encoded as UTF-8 before hashing.
+        wif (str): Private key in Wallet Import Format (WIF).
+        hashfn (callable, optional): Hash function to apply to the message prior to recovery-parameter computation; defaults to hashlib.sha256.
 
-    :param str wif: Private key in
+    Returns:
+        bytes: 65-byte compact signature: 1-byte recovery/version prefix (recovery parameter adjusted for compact/compressed form) followed by the 64-byte R||S sequence.
     """
 
     if not isinstance(message, bytes):
         message = bytes(message, "utf-8")
 
-    digest = hashfn(message).digest()
-    priv_key = PrivateKey(wif)
-    if SECP256K1_MODULE == "secp256k1":
-        p = bytes(priv_key)
-        ndata = secp256k1.ffi.new("const int *ndata")
-        ndata[0] = 0
-        while True:
-            ndata[0] += 1
-            privkey = secp256k1.PrivateKey(p, raw=True)
-            sig = secp256k1.ffi.new("secp256k1_ecdsa_recoverable_signature *")
-            signed = secp256k1.lib.secp256k1_ecdsa_sign_recoverable(
-                privkey.ctx, sig, digest, privkey.private_key, secp256k1.ffi.NULL, ndata
-            )
-            if not signed == 1:
-                raise AssertionError()
-            signature, i = privkey.ecdsa_recoverable_serialize(sig)
-            if _is_canonical(signature):
-                i += 4  # compressed
-                i += 27  # compact
-                break
-    elif SECP256K1_MODULE == "cryptography":
-        cnt = 0
-        private_key = ec.derive_private_key(
-            int(repr(priv_key), 16), ec.SECP256K1(), default_backend()
-        )
-        public_key = private_key.public_key()
-        while True:
-            cnt += 1
-            if not cnt % 20:
-                log.info("Still searching for a canonical signature. Tried %d times already!" % cnt)
-            order = ecdsa.SECP256k1.order
-            sigder = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
-            r, s = decode_dss_signature(sigder)
-            signature = ecdsa.util.sigencode_string(r, s, order)
-            # Make sure signature is canonical!
-            #
-            sigder = bytearray(sigder)
-            lenR = sigder[3]
-            lenS = sigder[5 + lenR]
-            if lenR == 32 and lenS == 32:
-                # Derive the recovery parameter
-                #
-                i = recoverPubkeyParameter(message, digest, signature, public_key)
-                i += 4  # compressed
-                i += 27  # compact
-                break
-    else:  # pragma: no branch  # pragma: no cover
-        cnt = 0
-        p = bytes(priv_key)
-        sk = ecdsa.SigningKey.from_string(p, curve=ecdsa.SECP256k1)
-        while 1:
-            cnt += 1
-            if not cnt % 20:
-                log.info("Still searching for a canonical signature. Tried %d times already!" % cnt)
-
-            # Deterministic k
-            #
-            k = ecdsa.rfc6979.generate_k(
-                sk.curve.generator.order(),
-                sk.privkey.secret_multiplier,
-                hashlib.sha256,
-                hashlib.sha256(
-                    digest
-                    + struct.pack("d", time.time())  # use the local time to randomize the signature
-                ).digest(),
-            )
-
-            # Sign message
-            #
-            sigder = sk.sign_digest(digest, sigencode=ecdsa.util.sigencode_der, k=k)
+    # Detect if message is already a digest
+    prehashed = len(message) == hashfn().digest_size
 
-            # Reformating of signature
-            #
-            r, s = ecdsa.util.sigdecode_der(sigder, sk.curve.generator.order())
-            signature = ecdsa.util.sigencode_string(r, s, sk.curve.generator.order())
+    if prehashed:
+        digest = message
+        message_for_signing = message  # the digest
+        algorithm_for_signing = ec.ECDSA(Prehashed(hashes.SHA256()))
+        message_for_recovery = None
+    else:
+        digest = hashfn(message).digest()
+        message_for_signing = message
+        algorithm_for_signing = ec.ECDSA(hashes.SHA256())
+        message_for_recovery = message
 
-            # Make sure signature is canonical!
+    priv_key = PrivateKey(wif)
+    cnt = 0
+    private_key = ec.derive_private_key(int(repr(priv_key), 16), ec.SECP256K1(), default_backend())
+    public_key = private_key.public_key()
+    while True:
+        cnt += 1
+        if not cnt % 20:
+            log.info("Still searching for a canonical signature. Tried %d times already!" % cnt)
+        order = ecdsa.SECP256k1.order
+        sigder = private_key.sign(message_for_signing, algorithm_for_signing)
+        r, s = decode_dss_signature(sigder)
+        signature = ecdsa.util.sigencode_string(r, s, order)
+        # Make sure signature is canonical!
+        #
+        sigder = bytearray(sigder)
+        lenR = sigder[3]
+        lenS = sigder[5 + lenR]
+        if lenR == 32 and lenS == 32 and _is_canonical(signature):
+            # Derive the recovery parameter
             #
-            sigder = bytearray(sigder)
-            lenR = sigder[3]
-            lenS = sigder[5 + lenR]
-            if lenR == 32 and lenS == 32:
-                # Derive the recovery parameter
-                #
-                i = recoverPubkeyParameter(message, digest, signature, sk.get_verifying_key())
-                i += 4  # compressed
-                i += 27  # compact
-                break
+            i = recoverPubkeyParameter(message_for_recovery, digest, signature, public_key)
+            if i is None:
+                continue
+            i += 4  # compressed
+            i += 27  # compact
+            break
 
     # pack signature
     #
@@ -265,6 +255,23 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
 
 
 def verify_message(message, signature, hashfn=hashlib.sha256, recover_parameter=None):
+    """
+    Verify an ECDSA secp256k1 signature against a message and return the signer's compressed public key.
+
+    Parameters:
+        message (bytes or str): The message to verify. If a str, it will be UTF-8 encoded.
+        signature (bytes or str): 65-byte compact signature where the first byte encodes the recovery parameter/version and the remaining 64 bytes are R||S. If a str, it will be UTF-8 encoded.
+        hashfn (callable): Hash function constructor used to compute the digest of the message (default: hashlib.sha256).
+        recover_parameter (int, optional): Explicit recovery parameter (0–3). If omitted, it is extracted from the signature's first byte.
+
+    Returns:
+        bytes: The 33-byte compressed public key of the recovered signer on successful verification.
+
+    Notes:
+        - The function computes the digest of `message` with `hashfn`, recovers the public key using the recovery parameter, converts the 64-byte R||S into DER form, and verifies the signature with ECDSA-SHA256.
+        - If the recovery parameter cannot be determined from the signature, None is returned.
+        - Cryptographic verification errors (e.g., invalid signature) will propagate as raised exceptions.
+    """
     if not isinstance(message, bytes):
         message = bytes(message, "utf-8")
     if not isinstance(signature, bytes):
@@ -281,41 +288,10 @@ def verify_message(message, signature, hashfn=hashlib.sha256, recover_parameter=
         log.info("Could not recover parameter")
         return None
 
-    if SECP256K1_MODULE == "secp256k1":
-        ALL_FLAGS = secp256k1.lib.SECP256K1_CONTEXT_VERIFY | secp256k1.lib.SECP256K1_CONTEXT_SIGN
-        # Placeholder
-        pub = secp256k1.PublicKey(flags=ALL_FLAGS)
-        # Recover raw signature
-        sig = pub.ecdsa_recoverable_deserialize(sig, recover_parameter)
-        # Recover PublicKey
-        verifyPub = secp256k1.PublicKey(pub.ecdsa_recover(message, sig))
-        # Convert recoverable sig to normal sig
-        normalSig = verifyPub.ecdsa_recoverable_convert(sig)
-        # Verify
-        verifyPub.ecdsa_verify(message, normalSig)
-        phex = verifyPub.serialize(compressed=True)
-    elif SECP256K1_MODULE == "cryptography":
-        p = recover_public_key(digest, sig, recover_parameter, message)
-        order = ecdsa.SECP256k1.order
-        r, s = ecdsa.util.sigdecode_string(sig, order)
-        sigder = encode_dss_signature(r, s)
-        p.verify(sigder, message, ec.ECDSA(hashes.SHA256()))
-        phex = compressedPubkey(p)
-    else:  # pragma: no branch  # pragma: no cover
-        p = recover_public_key(digest, sig, recover_parameter)
-        # Will throw an exception of not valid
-        p.verify_digest(sig, digest, sigdecode=ecdsa.util.sigdecode_string)
-        phex = compressedPubkey(p)
-
+    p = recover_public_key(digest, sig, recover_parameter, message)
+    order = ecdsa.SECP256k1.order
+    r, s = ecdsa.util.sigdecode_string(sig, order)
+    sigder = encode_dss_signature(r, s)
+    p.verify(sigder, digest, ec.ECDSA(Prehashed(hashes.SHA256())))
+    phex = compressedPubkey(p)
     return phex
-
-
-def tweakaddPubkey(pk, digest256, SECP256K1_MODULE=SECP256K1_MODULE):
-    if SECP256K1_MODULE == "secp256k1":
-        tmp_key = secp256k1.PublicKey(pubkey=bytes(pk), raw=True)
-        new_key = tmp_key.tweak_add(digest256)  # <-- add
-        raw_key = hexlify(new_key.serialize()).decode("ascii")
-    else:
-        raise Exception("Must have secp256k1 for `tweak_add`")
-        # raw_key = ecmult(pk, 1, digest256, SECP256K1_MODULE)
-    return PublicKey(raw_key, prefix=pk.prefix)

nectargraphenebase/types.py

@@ -3,9 +3,11 @@ import json
 import struct
 import time
 from binascii import hexlify, unhexlify
-from calendar import timegm
+
+# Move calendar import to avoid circular import issue in Python 3.13
 from datetime import datetime
 
+# Import calendar only when needed to avoid circular imports
 timeformat = "%Y-%m-%dT%H:%M:%S%Z"
 
 
@@ -265,11 +267,23 @@ class PointInTime(object):
         self.data = d
 
     def __bytes__(self):
-        """Returns bytes representation."""
+        """
+        Return a 4-byte little-endian Unix timestamp for the stored point-in-time.
+
+        If the instance holds a datetime, it is converted to a POSIX timestamp using UTC. If it holds a string, the string is parsed (with the module-level `timeformat` and "UTC" appended) and converted to a POSIX timestamp. The timestamp is encoded as a signed 32-bit little-endian integer when negative, otherwise as an unsigned 32-bit little-endian integer.
+        """
+        # Import lazily to avoid import-time cycles
+        from calendar import timegm
+
         if isinstance(self.data, datetime):
-            unixtime = timegm(self.data.timetuple())
+            # Use UTC, not local time
+            unixtime = timegm(self.data.utctimetuple())
         else:
-            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat))
+            s = self.data
+            # Accept ISO8601 'Z' suffix
+            if isinstance(s, str) and s.endswith("Z"):
+                s = s[:-1]
+            unixtime = timegm(time.strptime((s + "UTC"), timeformat))
         if unixtime < 0:
             return struct.pack("<i", unixtime)
         return struct.pack("<I", unixtime)

nectargraphenebase/unsignedtransactions.py

@@ -104,7 +104,7 @@ class Unsigned_Transaction(GrapheneObjectASN1):
         else:
             if len(args) == 1 and len(kwargs) == 0:
                 kwargs = args[0]
-            prefix = kwargs.pop("prefix", "STM")
+            kwargs.pop("prefix", "STM")
             if "extensions" not in kwargs:
                 kwargs["extensions"] = Set([])
             elif not kwargs.get("extensions"):

nectargraphenebase/version.py

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

hive_nectar-0.0.11.dist-info/RECORD

@@ -1,91 +0,0 @@
-nectar/__init__.py,sha256=ykNGWDHaB3B2l22VK3HF8jpXXUf78tb6uyUw_Gnq6Kc,522
-nectar/account.py,sha256=R__rmM8RwgKlO0-wwCo3jWecjz7WP6BxJEtLLVDhOXg,172221
-nectar/amount.py,sha256=m5u0ixthz-XY69yEhla8yu6iKQACOcNtpKlK1NY__v0,18057
-nectar/asciichart.py,sha256=DwPyZAqne6o9L_PPRtlw6Xj0QdOZ-aId1lpOnmbyc6Q,8828
-nectar/asset.py,sha256=spGsJmlVQeZ6-oYhcwmQKsI3gpGmrpCzimYO1Qv4MtA,2725
-nectar/block.py,sha256=6UIKzeKaPBOE2kRopTbnT0wAyz0g_FOJ4EuTZWMKA0Y,16050
-nectar/blockchain.py,sha256=jLJ6Lsw35nwamzhcSXnU1UOtrEacBlDIINXUnYQS_P0,49101
-nectar/blockchaininstance.py,sha256=dYGvI5JpNNHP6XOttIX3QR12fkuBCqek1O5DgDFdZwQ,93159
-nectar/blockchainobject.py,sha256=bgfEjTGjFaUputmfNCD1jRTqk1d94tbnujYGkNshsWs,6984
-nectar/blurt.py,sha256=2qRZf9-k5vonJEd-e8Dnpb09GP5bRvP5fE_MItSpCZw,23013
-nectar/cli.py,sha256=zQHYUbqEW-TPvEsYuILrYxuynhGJHLSWJiez3mxcKsg,227615
-nectar/comment.py,sha256=yL1JdFTEl6a47homQZHHSmOfeRzdtw1BVAFTTp5-yRo,46664
-nectar/community.py,sha256=EUCPSgHDWQIeFvO4zHOIl15dcfmEHN6VU2m1jHKVWxo,31821
-nectar/constants.py,sha256=lrspBwCz9BE0YZY10DMS98oPwwxgmI0LzFdlQ7v53Ig,4974
-nectar/conveyor.py,sha256=atw49yhCEPEGIVdcSL0T0Y0_DY-vp6MCWOm2umBbgXo,11203
-nectar/discussions.py,sha256=n-4GnYvnDc5AwFdUHSA9wTfdCmLWHb9h06U4vWq05q4,66439
-nectar/exceptions.py,sha256=AKA75cDNnpioZPe2XcNWvyAVPRLcHBfPyBwjYVFOJC0,2884
-nectar/hive.py,sha256=SjTTbLt_wWshEbaJFxjAPYT38wTa1i5RgBNepdeoAcw,22197
-nectar/hivesigner.py,sha256=DpHMdGhsy7Kh8gfcEAeHtFHEXOVTr0AqeZBXxgQNzIQ,14010
-nectar/imageuploader.py,sha256=dR6bd-CtHcKReLHuWsF_XmE_uJfqWxyWbU6lLhI2iM8,2647
-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=wNSFJyqaRL4dh_OKXui4jVXoGIIIgVBtB8K3bPCfNfY,18659
-nectar/price.py,sha256=Rv-ffhkyN1c-tl6QTGWvhrdqTQNHbE1rcUzTi21t4Tc,21052
-nectar/profile.py,sha256=t-pqC2DZxzvTV2XLU6iZWT1NdHuk77A_iiisbA0QIOM,1921
-nectar/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectar/rc.py,sha256=XRscyDqXiw03cBDznUPafEdhB64jxkrn6pH1kvoLcW4,12773
-nectar/snapshot.py,sha256=_5hsrmJDpPoWTYtQGZ2grMMuuGBInOGS0ip9gv5-RJo,31696
-nectar/steem.py,sha256=z7yrhWbnkVF4PzlpvG-JO4tqEFYZZ5dnqC5YMchnWFY,23859
-nectar/storage.py,sha256=efmvfBD102ye8TTCRhMUkegVNmASFAYCfV9qqSFSSJM,1844
-nectar/transactionbuilder.py,sha256=S14zLfbyvrMCnTOAAOUf6gqvU3aEyPDRZqEbYPYl4DM,25886
-nectar/utils.py,sha256=8mlRkx133yeZPkYgDUKLK79PVLRYIvJV1qts_V3pLjY,18884
-nectar/version.py,sha256=9aPmBLTmfKZ2C3bmweqIUOMrBvbWXo3Nvh-mGPpVVyI,77
-nectar/vote.py,sha256=-FHyrF79K4zmvH_IYl-2ImrX6pUhSs0dS7wCMeJAYh8,20085
-nectar/wallet.py,sha256=mbFNDbzo8PbcN7iYlVwwFIp9e4zCFuS4cYoWeepF1jY,16232
-nectar/witness.py,sha256=88XYjhTRNhyu9hfIG0sm3Pg1hC9eooo3HhW5EhcaYps,23600
-nectarapi/__init__.py,sha256=eyiQRdZ8agc_qi9fr8sAvYPfpStEpTN06yBWFxkCTJk,176
-nectarapi/exceptions.py,sha256=gDaDFy1QcFkXrpOadduZ9bFWanHZpaiZRK_AOJZ-AWo,2044
-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=9aPmBLTmfKZ2C3bmweqIUOMrBvbWXo3Nvh-mGPpVVyI,77
-nectarbase/__init__.py,sha256=O11coqB-Woq_yp946kA1b8hzqSdDcK9j9gwenx7d6JE,253
-nectarbase/ledgertransactions.py,sha256=0N1EHIZJdp-pVXmd0PgIVwhCFUtPRky4Pt9RQdP4f2A,2488
-nectarbase/memo.py,sha256=Ix5Uhan7x2rz54_QMSQ-Z5rZz-FqvR3i13H3cGEnPIY,7496
-nectarbase/objects.py,sha256=zDDLTz0eaenBDiZf_T1E9nXehU3xTs0aZyrrttkGKSk,14813
-nectarbase/objecttypes.py,sha256=zrKBFwoUJXvWDSn8RugWioKqf7TS7dY0EEXVAZv_-K0,690
-nectarbase/operationids.py,sha256=wpKltPFlInpueyvLl3XCI2fjP9ziIs4MStoIj2mbPfQ,3645
-nectarbase/operations.py,sha256=Ik87L6_rzptfCy4eeOX--9669mcrZ6SVxQe7jrmHd5U,47419
-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=9aPmBLTmfKZ2C3bmweqIUOMrBvbWXo3Nvh-mGPpVVyI,77
-nectargrapheneapi/__init__.py,sha256=_Gxdt_qaQQwwYABHEFBuf4tMh93ItIa3HPBH9nk1PTw,151
-nectargrapheneapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectargraphenebase/__init__.py,sha256=66IxULO3eMKcx-nRDFDLz0YfEvXCkty08xjt9M1WgyY,577
-nectargraphenebase/account.py,sha256=tjEbiqkFmTs0AZAaCRke3OzopHKV4i3deryCAR54xek,28984
-nectargraphenebase/aes.py,sha256=BywHJR8F7n2IBXhBmXqyc61DlVXcJ_QIE9qkubFdX2M,1578
-nectargraphenebase/base58.py,sha256=7ilcjbwV3YGDL3a5MCilR03P-p5kNVafrmsRsftr0d8,5410
-nectargraphenebase/bip32.py,sha256=UjqgbBvvdya3gQRD73ccdfEQL4brxs4DWhM9vTvRMpc,16023
-nectargraphenebase/bip38.py,sha256=EIlaNMvDHOhb4GKTcjX_8X8FWIG45pP3VTyoZD70Mh4,4458
-nectargraphenebase/chains.py,sha256=JhaqY8qZaK-6OYf72RLVNxJtrc6yZtYxJm8p9U-i338,6185
-nectargraphenebase/dictionary.py,sha256=Fooynl3XWE9ALy31jsVNb9CEHZh5N8TeJUAZJvqslnY,360748
-nectargraphenebase/ecdsasig.py,sha256=Etv1C83GpkhGFgWrHoB7WR4T_Ygh4SZ-6Qlnc9XCYHY,12129
-nectargraphenebase/objects.py,sha256=twOADiBOSXlZNu6y1TrdDw135zWQeIsfn12xRl5m6Fw,3896
-nectargraphenebase/objecttypes.py,sha256=8YkRyxtd1hNZ06XvyHBRA5PatVeTd8XCFQmW_2p8MGk,160
-nectargraphenebase/operationids.py,sha256=TLXB8FovmDwC39PNAR8OaW-NWyo1gFH0zE4ibShcMiI,65
-nectargraphenebase/operations.py,sha256=Lp25CSjHUttzWLbcgYLeccFtPHqip8uo9iTqLKKm40U,690
-nectargraphenebase/prefix.py,sha256=tpX2_uz5lPveUoGbmXC4zsrG-5QsaVbIGIFPWJvYRbg,280
-nectargraphenebase/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectargraphenebase/signedtransactions.py,sha256=rhFEQDNcOau08qnNAf_3UxJDXtIpi5Y8tOFDXZK1bPw,7119
-nectargraphenebase/types.py,sha256=nxkpR4N1DOZwIwDSVQrMxp8VZVKVjYdiLvPv0sX65jU,9439
-nectargraphenebase/unsignedtransactions.py,sha256=6WLZCSVC0vCa7VVBt39TQl1vW-GAF2khkF0DLIgZG-s,9247
-nectargraphenebase/version.py,sha256=9aPmBLTmfKZ2C3bmweqIUOMrBvbWXo3Nvh-mGPpVVyI,77
-nectarstorage/__init__.py,sha256=nEM9OMoHqHPS6IoV_JzVyxPRORz0DCeS7Yv-MwjmWoQ,1772
-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=xOAOZvVfIctfGiwIed_XpKnWcGDla95qp8osTLyYYCk,8654
-nectarstorage/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nectarstorage/ram.py,sha256=Cy6JbMrlgcEG673_KqfyaofhAdJR-luRKTedj3qTZEE,1034
-nectarstorage/sqlite.py,sha256=ZKJxPL0AZjJIlwjxCEh6GGcjQzlBPuWs6tj40oPZz3M,10635
-hive_nectar-0.0.11.dist-info/METADATA,sha256=GcTDdw97TsV6-QWUjcs18n66gVdpPgqgf3-0RpK4BXg,6163
-hive_nectar-0.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hive_nectar-0.0.11.dist-info/entry_points.txt,sha256=DbqiJb5fFpQvGZ0ojvc2w3dXZitTg6FPz09CobKq4m8,47
-hive_nectar-0.0.11.dist-info/licenses/LICENSE.txt,sha256=WjJRNR4r7FuLEO2BTBLGa05T7bBecGGgH47NgKsSY0E,1158
-hive_nectar-0.0.11.dist-info/RECORD,,