hive-nectar 0.0.2__py3-none-any.whl

nectarbase/memo.py

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+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:
+    from Cryptodome.Cipher import AES
+except ImportError:
+    try:
+        from Crypto.Cipher import AES
+    except ImportError:
+        raise ImportError("Missing dependency: pyCryptodome")
+import struct
+
+from nectargraphenebase.account import PublicKey
+
+from .objects import Memo
+
+default_prefix = "STM"
+
+
+def get_shared_secret(priv, pub):
+    """Derive the share secret between ``priv`` and ``pub``
+    :param `Base58` priv: Private Key
+    :param `Base58` pub: Public Key
+    :return: Shared secret
+    :rtype: hex
+    The shared secret is generated such that::
+        Pub(Alice) * Priv(Bob) = Pub(Bob) * Priv(Alice)
+    """
+    pub_point = pub.point()
+    priv_point = int(repr(priv), 16)
+    res = pub_point * priv_point
+    res_hex = "%032x" % res.x()
+    # Zero padding
+    res_hex = "0" * (64 - len(res_hex)) + res_hex
+    return res_hex
+
+
+def init_aes(shared_secret, nonce):
+    """Initialize AES instance
+    :param hex shared_secret: Shared Secret to use as encryption key
+    :param int nonce: Random nonce
+    :return: AES instance
+    :rtype: AES
+    """
+    " Shared Secret "
+    ss = hashlib.sha512(unhexlify(shared_secret)).digest()
+    " Seed "
+    seed = py23_bytes(str(nonce), "ascii") + hexlify(ss)
+    seed_digest = hexlify(hashlib.sha512(seed).digest()).decode("ascii")
+    " AES "
+    key = unhexlify(seed_digest[0:64])
+    iv = unhexlify(seed_digest[64:96])
+    return AES.new(key, AES.MODE_CBC, iv)
+
+
+def init_aes_bts(shared_secret, nonce):
+    """Initialize AES instance
+    :param hex shared_secret: Shared Secret to use as encryption key
+    :param int nonce: Random nonce
+    :return: AES instance
+    :rtype: AES
+    """
+    " Shared Secret "
+    ss = hashlib.sha512(unhexlify(shared_secret)).digest()
+    " Seed "
+    seed = bytes(str(nonce), "ascii") + hexlify(ss)
+    seed_digest = hexlify(hashlib.sha512(seed).digest()).decode("ascii")
+    " AES "
+    key = unhexlify(seed_digest[0:64])
+    iv = unhexlify(seed_digest[64:96])
+    return AES.new(key, AES.MODE_CBC, iv)
+
+
+def init_aes(shared_secret, nonce):
+    """Initialize AES instance
+    :param hex shared_secret: Shared Secret to use as encryption key
+    :param int nonce: Random nonce
+    """
+    shared_secret = hashlib.sha512(unhexlify(shared_secret)).hexdigest()
+    # Seed
+    ss = unhexlify(shared_secret)
+    n = struct.pack("<Q", int(nonce))
+    encryption_key = hashlib.sha512(n + ss).hexdigest()
+    # Check'sum'
+    check = hashlib.sha256(unhexlify(encryption_key)).digest()
+    check = struct.unpack_from("<I", check[:4])[0]
+    # AES
+    key = unhexlify(encryption_key[0:64])
+    iv = unhexlify(encryption_key[64:96])
+    return AES.new(key, AES.MODE_CBC, iv), check
+
+
+def _pad(s, BS):
+    numBytes = BS - len(s) % BS
+    return s + numBytes * struct.pack("B", numBytes)
+
+
+def _unpad(s, BS):
+    count = s[-1]
+    if s[-count::] == count * struct.pack("B", count):
+        return s[:-count]
+    return s
+
+
+def encode_memo_bts(priv, pub, nonce, message):
+    """Encode a message with a shared secret between Alice and Bob
+
+    :param PrivateKey priv: Private Key (of Alice)
+    :param PublicKey pub: Public Key (of Bob)
+    :param int nonce: Random nonce
+    :param str message: Memo message
+    :return: Encrypted message
+    :rtype: hex
+
+    """
+    shared_secret = get_shared_secret(priv, pub)
+    aes = init_aes_bts(shared_secret, nonce)
+    " Checksum "
+    raw = py23_bytes(message, "utf8")
+    checksum = hashlib.sha256(raw).digest()
+    raw = checksum[0:4] + raw
+    " Padding "
+    raw = _pad(raw, 16)
+    " Encryption "
+    return hexlify(aes.encrypt(raw)).decode("ascii")
+
+
+def decode_memo_bts(priv, pub, nonce, message):
+    """Decode a message with a shared secret between Alice and Bob
+
+    :param PrivateKey priv: Private Key (of Bob)
+    :param PublicKey pub: Public Key (of Alice)
+    :param int nonce: Nonce used for Encryption
+    :param bytes message: Encrypted Memo message
+    :return: Decrypted message
+    :rtype: str
+    :raise ValueError: if message cannot be decoded as valid UTF-8
+           string
+
+    """
+    shared_secret = get_shared_secret(priv, pub)
+    aes = init_aes_bts(shared_secret, nonce)
+    " Encryption "
+    raw = py23_bytes(message, "ascii")
+    cleartext = aes.decrypt(unhexlify(raw))
+    " Checksum "
+    checksum = cleartext[0:4]
+    message = cleartext[4:]
+    message = _unpad(message, 16)
+    " Verify checksum "
+    check = hashlib.sha256(message).digest()[0:4]
+    if check != checksum:  # pragma: no cover
+        raise ValueError("checksum verification failure")
+    return message.decode("utf8")
+
+
+def encode_memo(priv, pub, nonce, message, **kwargs):
+    """Encode a message with a shared secret between Alice and Bob
+
+    :param PrivateKey priv: Private Key (of Alice)
+    :param PublicKey pub: Public Key (of Bob)
+    :param int nonce: Random nonce
+    :param str message: Memo message
+    :return: Encrypted message
+    :rtype: hex
+    """
+    shared_secret = get_shared_secret(priv, pub)
+    aes, check = init_aes(shared_secret, nonce)
+    " Padding "
+    raw = py23_bytes(message, "utf8")
+    raw = _pad(raw, 16)
+    " Encryption "
+    cipher = hexlify(aes.encrypt(raw)).decode("ascii")
+    prefix = kwargs.pop("prefix", default_prefix)
+    s = {
+        "from": format(priv.pubkey, prefix),
+        "to": format(pub, prefix),
+        "nonce": nonce,
+        "check": check,
+        "encrypted": cipher,
+        "prefix": prefix,
+    }
+    tx = Memo(**s)
+    return "#" + base58encode(hexlify(py23_bytes(tx)).decode("ascii"))
+
+
+def extract_memo_data(message):
+    """Returns the stored pubkey keys, nonce, checksum and encrypted message of a memo"""
+    raw = base58decode(message[1:])
+    from_key = PublicKey(raw[:66])
+    raw = raw[66:]
+    to_key = PublicKey(raw[:66])
+    raw = raw[66:]
+    nonce = str(struct.unpack_from("<Q", unhexlify(raw[:16]))[0])
+    raw = raw[16:]
+    check = struct.unpack_from("<I", unhexlify(raw[:8]))[0]
+    raw = raw[8:]
+    cipher = raw
+    return from_key, to_key, nonce, check, cipher
+
+
+def decode_memo(priv, message):
+    """Decode a message with a shared secret between Alice and Bob
+
+    :param PrivateKey priv: Private Key (of Bob)
+    :param base58encoded message: Encrypted Memo message
+    :return: Decrypted message
+    :rtype: str
+    :raise ValueError: if message cannot be decoded as valid UTF-8
+           string
+    """
+    # decode structure
+    from_key, to_key, nonce, check, cipher = extract_memo_data(message)
+
+    if repr(to_key) == repr(priv.pubkey):
+        shared_secret = get_shared_secret(priv, from_key)
+    elif repr(from_key) == repr(priv.pubkey):
+        shared_secret = get_shared_secret(priv, to_key)
+    else:
+        raise ValueError("Incorrect PrivateKey")
+
+    # Init encryption
+    aes, checksum = init_aes(shared_secret, nonce)
+    # Check
+    if not check == checksum:
+        raise AssertionError("Checksum failure")
+    # Encryption
+    # remove the varint prefix (FIXME, long messages!)
+    numBytes = 16 - len(cipher) % 16
+    n = 16 - numBytes
+    message = cipher[n:]
+    message = aes.decrypt(unhexlify(py23_bytes(message, "ascii")))
+    message = _unpad(message, 16)
+    n = varintdecode(message)
+    if (len(message) - n) > 0 and (len(message) - n) < 8:
+        return "#" + message[len(message) - n :].decode("utf8")
+    else:
+        return "#" + message.decode("utf8")

nectarbase/objects.py

@@ -0,0 +1,429 @@
+# -*- coding: utf-8 -*-
+import decimal
+import json
+import struct
+from collections import OrderedDict
+
+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,
+    Id,
+    Int16,
+    Map,
+    PointInTime,
+    Static_variant,
+    String,
+    Uint16,
+    Uint32,
+    Uint64,
+)
+
+from .operationids import operations
+
+default_prefix = "STM"
+
+
+def value_to_decimal(value, decimal_places):
+    decimal.getcontext().rounding = decimal.ROUND_DOWN  # define rounding method
+    return decimal.Decimal(str(float(value))).quantize(
+        decimal.Decimal("1e-{}".format(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):
+            self.amount, self.symbol = d.strip().split(" ")
+            self.precision = None
+            for c in known_chains:
+                if self.precision is not None:
+                    continue
+                if known_chains[c]["prefix"] != prefix:
+                    continue
+                for asset in known_chains[c]["chain_assets"]:
+                    if self.precision is not None:
+                        continue
+                    if asset["symbol"] == self.symbol:
+                        self.precision = asset["precision"]
+                        self.asset = asset["asset"]
+                    elif asset["asset"] == self.symbol:
+                        self.precision = asset["precision"]
+                        self.asset = asset["asset"]
+            if self.precision is None:
+                raise Exception("Asset unknown")
+            self.amount = round(value_to_decimal(self.amount, self.precision) * 10**self.precision)
+            # Workaround to allow transfers in HIVE
+
+            self.str_repr = "{:.{}f} {}".format(
+                (float(self.amount) / 10**self.precision), self.precision, self.symbol
+            )
+        elif isinstance(d, list):
+            self.amount = d[0]
+            self.asset = d[2]
+            self.precision = d[1]
+            self.symbol = None
+            for c in known_chains:
+                if known_chains[c]["prefix"] != prefix:
+                    continue
+                for asset in known_chains[c]["chain_assets"]:
+                    if asset["asset"] == self.asset:
+                        self.symbol = asset["symbol"]
+            if self.symbol is None:
+                raise ValueError("Unknown NAI, cannot resolve symbol")
+            a = Array([String(d[0]), d[1], d[2]])
+            self.str_repr = str(a.__str__())
+        elif isinstance(d, dict) and "nai" in d:
+            self.asset = d["nai"]
+            self.symbol = None
+            for c in known_chains:
+                if known_chains[c]["prefix"] != prefix:
+                    continue
+                for asset in known_chains[c]["chain_assets"]:
+                    if asset["asset"] == d["nai"]:
+                        self.symbol = asset["symbol"]
+            if self.symbol is None:
+                raise ValueError("Unknown NAI, cannot resolve symbol")
+            self.amount = d["amount"]
+            self.precision = d["precision"]
+            self.str_repr = json.dumps(d)
+        else:
+            self.amount = d.amount
+            self.symbol = d.symbol
+            self.asset = d.asset["asset"]
+            self.precision = d.asset["precision"]
+            self.amount = round(value_to_decimal(self.amount, self.precision) * 10**self.precision)
+            self.str_repr = str(d)
+            # self.str_repr = json.dumps((d.json()))
+            # self.str_repr = '{:.{}f} {}'.format((float(self.amount) / 10 ** self.precision), self.precision, self.asset)
+
+    def __bytes__(self):
+        # padding
+        # Workaround to allow transfers in HIVE
+        if self.symbol == "HBD":
+            self.symbol = "SBD"
+        elif self.symbol == "HIVE":
+            self.symbol = "STEEM"
+        symbol = self.symbol + "\x00" * (7 - len(self.symbol))
+        return (
+            struct.pack("<q", int(self.amount))
+            + struct.pack("<b", self.precision)
+            + py23_bytes(symbol, "ascii")
+        )
+
+    def __str__(self):
+        if self.json_str:
+            return json.dumps(
+                {"amount": str(self.amount), "precision": self.precision, "nai": self.asset}
+            )
+        return self.str_repr
+
+
+class Operation(GPHOperation):
+    def __init__(self, *args, **kwargs):
+        self.appbase = kwargs.pop("appbase", False)
+        self.prefix = kwargs.pop("prefix", default_prefix)
+        super(Operation, self).__init__(*args, **kwargs)
+
+    def _getklass(self, name):
+        module = __import__("nectarbase.operations", fromlist=["operations"])
+        class_ = getattr(module, name)
+        return class_
+
+    def operations(self):
+        return operations
+
+    def getOperationNameForId(self, i):
+        """Convert an operation id into the corresponding string"""
+        for key in self.operations():
+            if int(self.operations()[key]) is int(i):
+                return key
+        return "Unknown Operation ID %d" % i
+
+    def json(self):
+        return json.loads(str(self))
+        # return json.loads(str(json.dumps([self.name, self.op.toJson()])))
+
+    def __bytes__(self):
+        return py23_bytes(Id(self.opId)) + py23_bytes(self.op)
+
+    def __str__(self):
+        if self.appbase:
+            return json.dumps({"type": self.name.lower() + "_operation", "value": self.op.toJson()})
+        else:
+            return json.dumps([self.name.lower(), self.op.toJson()])
+
+
+class Memo(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            prefix = kwargs.pop("prefix", default_prefix)
+            if "encrypted" not in kwargs or not kwargs["encrypted"]:
+                super(Memo, self).__init__(None)
+            else:
+                if len(args) == 1 and len(kwargs) == 0:
+                    kwargs = args[0]
+                if "encrypted" in kwargs and kwargs["encrypted"]:
+                    super(Memo, self).__init__(
+                        OrderedDict(
+                            [
+                                ("from", PublicKey(kwargs["from"], prefix=prefix)),
+                                ("to", PublicKey(kwargs["to"], prefix=prefix)),
+                                ("nonce", Uint64(int(kwargs["nonce"]))),
+                                ("check", Uint32(int(kwargs["check"]))),
+                                ("encrypted", Bytes(kwargs["encrypted"])),
+                            ]
+                        )
+                    )
+
+
+class WitnessProps(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            prefix = kwargs.get("prefix", default_prefix)
+            if "sbd_interest_rate" in kwargs:
+                super(WitnessProps, self).__init__(
+                    OrderedDict(
+                        [
+                            (
+                                "account_creation_fee",
+                                Amount(kwargs["account_creation_fee"], prefix=prefix),
+                            ),
+                            ("maximum_block_size", Uint32(kwargs["maximum_block_size"])),
+                            ("sbd_interest_rate", Uint16(kwargs["sbd_interest_rate"])),
+                        ]
+                    )
+                )
+            elif "hbd_interest_rate" in kwargs:
+                super(WitnessProps, self).__init__(
+                    OrderedDict(
+                        [
+                            (
+                                "account_creation_fee",
+                                Amount(kwargs["account_creation_fee"], prefix=prefix),
+                            ),
+                            ("maximum_block_size", Uint32(kwargs["maximum_block_size"])),
+                            ("hbd_interest_rate", Uint16(kwargs["hbd_interest_rate"])),
+                        ]
+                    )
+                )
+            else:
+                super(WitnessProps, self).__init__(
+                    OrderedDict(
+                        [
+                            (
+                                "account_creation_fee",
+                                Amount(kwargs["account_creation_fee"], prefix=prefix),
+                            ),
+                            ("maximum_block_size", Uint32(kwargs["maximum_block_size"])),
+                        ]
+                    )
+                )
+
+
+class Price(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+            prefix = kwargs.get("prefix", default_prefix)
+            super(Price, self).__init__(
+                OrderedDict(
+                    [
+                        ("base", Amount(kwargs["base"], prefix=prefix)),
+                        ("quote", Amount(kwargs["quote"], prefix=prefix)),
+                    ]
+                )
+            )
+
+
+class Permission(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            prefix = kwargs.pop("prefix", default_prefix)
+
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            # Sort keys (FIXME: ideally, the sorting is part of Public
+            # Key and not located here)
+            kwargs["key_auths"] = sorted(
+                kwargs["key_auths"],
+                key=lambda x: repr(PublicKey(x[0], prefix=prefix)),
+                reverse=False,
+            )
+            kwargs["account_auths"] = sorted(
+                kwargs["account_auths"],
+                key=lambda x: x[0],
+                reverse=False,
+            )
+            accountAuths = Map([[String(e[0]), Uint16(e[1])] for e in kwargs["account_auths"]])
+            keyAuths = Map(
+                [[PublicKey(e[0], prefix=prefix), Uint16(e[1])] for e in kwargs["key_auths"]]
+            )
+            super(Permission, self).__init__(
+                OrderedDict(
+                    [
+                        ("weight_threshold", Uint32(int(kwargs["weight_threshold"]))),
+                        ("account_auths", accountAuths),
+                        ("key_auths", keyAuths),
+                    ]
+                )
+            )
+
+
+class Extension(Array):
+    def __str__(self):
+        """We overload the __str__ function because the json
+        representation is different for extensions
+        """
+        return json.dumps(self.json)
+
+
+class ExchangeRate(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            prefix = kwargs.get("prefix", default_prefix)
+            super(ExchangeRate, self).__init__(
+                OrderedDict(
+                    [
+                        ("base", Amount(kwargs["base"], prefix=prefix)),
+                        ("quote", Amount(kwargs["quote"], prefix=prefix)),
+                    ]
+                )
+            )
+
+
+class Beneficiary(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+        super(Beneficiary, self).__init__(
+            OrderedDict(
+                [
+                    ("account", String(kwargs["account"])),
+                    ("weight", Int16(kwargs["weight"])),
+                ]
+            )
+        )
+
+
+class Beneficiaries(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+        super(Beneficiaries, self).__init__(
+            OrderedDict(
+                [
+                    ("beneficiaries", Array([Beneficiary(o) for o in kwargs["beneficiaries"]])),
+                ]
+            )
+        )
+
+
+class CommentOptionExtensions(Static_variant):
+    """Serialize Comment Payout Beneficiaries.
+
+    :param list beneficiaries: A static_variant containing beneficiaries.
+
+    Example::
+
+        [0,
+            {'beneficiaries': [
+                {'account': 'furion', 'weight': 10000}
+            ]}
+        ]
+
+    """
+
+    def __init__(self, o):
+        if type(o) == dict and "type" in o and "value" in o:
+            if o["type"] == "comment_payout_beneficiaries":
+                type_id = 0
+            else:
+                type_id = ~0
+            data = o["value"]
+        else:
+            type_id, data = o
+        if type_id == 0:
+            data = Beneficiaries(data)
+        else:
+            raise Exception("Unknown CommentOptionExtension")
+        super(CommentOptionExtensions, self).__init__(data, type_id)
+
+
+class UpdateProposalEndDate(GrapheneObject):
+    def __init__(self, *args, **kwargs):
+        if isArgsThisClass(self, args):
+            self.data = args[0].data
+        else:
+            if len(args) == 1 and len(kwargs) == 0:
+                kwargs = args[0]
+
+            super(UpdateProposalEndDate, self).__init__(
+                OrderedDict(
+                    [
+                        ("end_date", PointInTime(kwargs["end_date"])),
+                    ]
+                )
+            )
+
+
+class UpdateProposalExtensions(Static_variant):
+    """Serialize Update proposal extensions.
+
+    :param end_date: A static_variant containing the new end_date.
+
+    Example::
+
+        {
+            'type': '1',
+            'value':
+                  {
+                    'end_date': '2021-04-05T13:39:48'
+                  }
+        }
+
+    """
+
+    def __init__(self, o):
+        if isinstance(o, dict) and "type" in o and "value" in o:
+            if o["type"] == "update_proposal_end_date":
+                type_id = 1
+            else:
+                type_id = ~0
+        else:
+            type_id, data = o
+
+        if type_id == 1:
+            data = UpdateProposalEndDate(o["value"])
+        else:
+            raise Exception("Unknown UpdateProposalExtension")
+        super(UpdateProposalExtensions, self).__init__(data, type_id, False)

nectarbase/objecttypes.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+#: Object types for object ids
+object_type = {}
+object_type["dynamic_global_property"] = 0
+object_type["reserved0"] = 1
+object_type["account"] = 2
+object_type["witness"] = 3
+object_type["transaction"] = 4
+object_type["block_summary"] = 5
+object_type["chain_property"] = 6
+object_type["witness_schedule"] = 7
+object_type["comment"] = 8
+object_type["category"] = 9
+object_type["comment_vote"] = 10
+object_type["vote"] = 11
+object_type["witness_vote"] = 12
+object_type["limit_order"] = 13
+object_type["feed_history"] = 14
+object_type["convert_request"] = 15
+object_type["liquidity_reward_balance"] = 16
+object_type["operation"] = 17
+object_type["account_history"] = 18