hive-nectar 0.2.9__py3-none-any.whl

nectarbase/objects.py

@@ -0,0 +1,521 @@
+import decimal
+import json
+import struct
+from collections import OrderedDict
+from typing import Any, Dict, Union
+
+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.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: Union[str, float, int], decimal_places: int) -> decimal.Decimal:
+    decimal.getcontext().rounding = decimal.ROUND_DOWN  # define rounding method
+    return decimal.Decimal(str(float(value))).quantize(
+        decimal.Decimal("1e-{}".format(decimal_places))
+    )
+
+
+class Amount:
+    def __init__(
+        self,
+        d: Union[str, Any],
+        prefix: str = default_prefix,
+        json_str: bool = False,
+        **kwargs,
+    ) -> None:
+        self.json_str = json_str
+        if isinstance(d, str):
+            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(float(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)
+        elif isinstance(d, dict) and "amount" in d and "asset" in d:
+            self.amount = d["amount"]
+            asset_obj = d["asset"]
+            self.precision = asset_obj["precision"]
+            self.asset = asset_obj.get("asset", asset_obj.get("nai"))
+            self.symbol = asset_obj.get("symbol")
+            self.amount = round(value_to_decimal(self.amount, self.precision) * 10**self.precision)
+            if hasattr(d, "json"):
+                self.str_repr = json.dumps(d.json())
+            else:
+                # Fallback or manual construction if needed, but for now just str(d) or skip
+                # If d is a dict with Decimal, we can't json dump it directly.
+                # But we only expect nectar.amount.Amount here which has .json()
+                self.str_repr = json.dumps(
+                    d
+                )  # This might still fail if not Amount object but just dict with Decimal
+
+        else:
+            self.amount = d.amount
+            self.symbol = d.symbol
+            self.asset = d.asset
+            self.precision = d.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) -> bytes:
+        # padding
+        # The nodes still serialize the legacy symbol name for HBD as 'SBD' and HIVE as 'STEEM' in wire format.
+        # To match get_transaction_hex and avoid digest mismatches, map 'HBD' -> 'SBD' and 'HIVE' -> 'STEEM' on serialization.
+        """
+        Serialize the Amount into its wire-format byte representation.
+
+        Returns:
+            bytes: 8-byte little-endian signed integer amount, followed by a 1-byte precision,
+                   followed by a 7-byte ASCII symbol padded with null bytes. On serialization,
+                   the symbol is remapped for legacy wire-format compatibility: "HBD" -> "SBD"
+                   and "HIVE" -> "STEEM".
+        """
+        _sym = self.symbol
+        if _sym == "HBD":
+            _sym = "SBD"
+        elif _sym == "HIVE":
+            _sym = "STEEM"
+        symbol = str(_sym) + "\x00" * (7 - len(str(_sym)))
+        return (
+            struct.pack("<q", int(self.amount))
+            + struct.pack("<b", self.precision)
+            + bytes(symbol, "ascii")
+        )
+
+    def __str__(self) -> str:
+        if self.json_str:
+            return json.dumps(
+                {
+                    "amount": str(self.amount),
+                    "precision": self.precision,
+                    "nai": self.asset,
+                }
+            )
+        return self.str_repr
+
+    def toJson(self):
+        try:
+            return json.loads(str(self))
+        except Exception:
+            return str(self)
+
+
+class Operation(GPHOperation):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.appbase = kwargs.pop("appbase", False)
+        self.prefix = kwargs.pop("prefix", default_prefix)
+        super().__init__(*args, **kwargs)
+
+    def _getklass(self, name: str) -> type:
+        module = __import__("nectarbase.operations", fromlist=["operations"])
+        class_ = getattr(module, name)
+        return class_
+
+    def operations(self) -> Dict[str, int]:
+        return operations
+
+    def getOperationNameForId(self, i: int) -> str:
+        """Convert an operation id into the corresponding string"""
+        for key in self.operations():
+            if int(self.operations()[key]) == int(i):
+                return key
+        return "Unknown Operation ID %d" % i
+
+    def json(self) -> Dict[str, Any]:
+        return json.loads(str(self))
+        # return json.loads(str(json.dumps([self.name, self.op.toJson()])))
+
+    def __bytes__(self) -> bytes:
+        if self.opId is not None:
+            return bytes(Id(self.opId)) + bytes(self.op)
+        return bytes(self.op)
+
+    def __str__(self) -> str:
+        if self.appbase:
+            op_data = self.op.toJson() if isinstance(self.op, GrapheneObject) else str(self.op)
+            return json.dumps({"type": self.name.lower() + "_operation", "value": op_data})
+        else:
+            op_data = self.op.toJson() if isinstance(self.op, GrapheneObject) else str(self.op)
+            return json.dumps([self.name.lower(), op_data])
+
+
+class Memo(GrapheneObject):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        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().__init__(None)
+            else:
+                if len(args) == 1 and len(kwargs) == 0:
+                    kwargs = args[0]
+                if "encrypted" in kwargs and kwargs["encrypted"]:
+                    super().__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)
+            json_str = kwargs.get("json_str", False)
+            if "sbd_interest_rate" in kwargs:
+                super().__init__(
+                    OrderedDict(
+                        [
+                            (
+                                "account_creation_fee",
+                                Amount(
+                                    kwargs["account_creation_fee"],
+                                    prefix=prefix,
+                                    json_str=json_str,
+                                ),
+                            ),
+                            (
+                                "maximum_block_size",
+                                Uint32(kwargs["maximum_block_size"]),
+                            ),
+                            ("sbd_interest_rate", Uint16(kwargs["sbd_interest_rate"])),
+                        ]
+                    )
+                )
+            elif "hbd_interest_rate" in kwargs:
+                super().__init__(
+                    OrderedDict(
+                        [
+                            (
+                                "account_creation_fee",
+                                Amount(
+                                    kwargs["account_creation_fee"],
+                                    prefix=prefix,
+                                    json_str=json_str,
+                                ),
+                            ),
+                            (
+                                "maximum_block_size",
+                                Uint32(kwargs["maximum_block_size"]),
+                            ),
+                            ("hbd_interest_rate", Uint16(kwargs["hbd_interest_rate"])),
+                        ]
+                    )
+                )
+            else:
+                super().__init__(
+                    OrderedDict(
+                        [
+                            (
+                                "account_creation_fee",
+                                Amount(
+                                    kwargs["account_creation_fee"],
+                                    prefix=prefix,
+                                    json_str=json_str,
+                                ),
+                            ),
+                            (
+                                "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().__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().__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.data if hasattr(self, "data") else [])
+
+
+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)
+            json_str = kwargs.get("json_str", False)
+            super().__init__(
+                OrderedDict(
+                    [
+                        (
+                            "base",
+                            Amount(kwargs["base"], prefix=prefix, json_str=json_str),
+                        ),
+                        (
+                            "quote",
+                            Amount(kwargs["quote"], prefix=prefix, json_str=json_str),
+                        ),
+                    ]
+                )
+            )
+
+
+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().__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().__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 isinstance(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().__init__(data, type_id)
+
+    def __str__(self):
+        if self.type_id == 0:
+            return json.dumps({"type": "comment_payout_beneficiaries", "value": self.data.json()})
+        return super().__str__()
+
+
+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().__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
+            data = o["value"]
+        else:
+            type_id, data = o
+
+        if type_id == 1:
+            data = UpdateProposalEndDate(data)
+        else:
+            raise Exception("Unknown UpdateProposalExtension")
+        super().__init__(data, type_id, False)
+
+    def __str__(self):
+        if self.type_id == 1:
+            return json.dumps({"type": "update_proposal_end_date", "value": self.data.json()})
+        return super().__str__()

nectarbase/objecttypes.py

@@ -0,0 +1,21 @@
+#: 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

nectarbase/operationids.py

@@ -0,0 +1,102 @@
+#: Operation ids
+from typing import Dict, List
+
+# https://gitlab.syncad.com/hive/hive/-/blob/master/libraries/protocol/include/hive/protocol/operations.hpp
+ops: List[str] = [
+    "vote",  # 0
+    "comment",  # 1
+    "transfer",  # 2
+    "transfer_to_vesting",  # 3
+    "withdraw_vesting",  # 4
+    "limit_order_create",  # 5
+    "limit_order_cancel",  # 6
+    "feed_publish",  # 7
+    "convert",  # 8
+    "account_create",  # 9
+    "account_update",  # 10
+    "witness_update",  # 11
+    "account_witness_vote",  # 12
+    "account_witness_proxy",  # 13
+    "pow",  # 14
+    "custom",  # 15
+    "report_over_production",  # 16
+    "delete_comment",  # 17
+    "custom_json",  # 18
+    "comment_options",  # 19
+    "set_withdraw_vesting_route",  # 20
+    "limit_order_create2",  # 21
+    "claim_account",  # 22
+    "create_claimed_account",  # 23
+    "request_account_recovery",  # 24
+    "recover_account",  # 25
+    "change_recovery_account",  # 26
+    "escrow_transfer",  # 27
+    "escrow_dispute",  # 28
+    "escrow_release",  # 29
+    "pow2",  # 30
+    "escrow_approve",  # 31
+    "transfer_to_savings",  # 32
+    "transfer_from_savings",  # 33
+    "cancel_transfer_from_savings",  # 34
+    "custom_binary",  # 35
+    "decline_voting_rights",  # 36
+    "reset_account",  # 37
+    "set_reset_account",  # 38
+    "claim_reward_balance",  # 39
+    "delegate_vesting_shares",  # 40
+    "account_create_with_delegation",  # 41
+    "witness_set_properties",  # 42
+    "account_update2",  # 43
+    "create_proposal",  # 44
+    "update_proposal_votes",  # 45
+    "remove_proposal",  # 46
+    "update_proposal",  # 47
+    "collateralized_convert",  # 48
+    "recurrent_transfer",  # 49
+    # virtual operations below this point
+    "fill_convert_request",  # last_regular + 1
+    "author_reward",  # last_regular + 2
+    "curation_reward",  # last_regular + 3
+    "comment_reward",  # last_regular + 4
+    "liquidity_reward",  # last_regular + 5
+    "interest",  # last_regular + 6
+    "fill_vesting_withdraw",  # last_regular + 7
+    "fill_order",  # last_regular + 8
+    "shutdown_witness",  # last_regular + 9
+    "fill_transfer_from_savings",  # last_regular + 10
+    "hardfork",  # last_regular + 11
+    "comment_payout_update",  # last_regular + 12
+    "return_vesting_delegation",  # last_regular + 13
+    "comment_benefactor_reward",  # last_regular + 14
+    "producer_reward",  # last_regular + 15
+    "clear_null_account_balance",  # last_regular + 16
+    "proposal_pay",  # last_regular + 17
+    "sps_fund",  # last_regular + 18
+    "hardfork_hive",  # last_regular + 19
+    "hardfork_hive_restore",  # last_regular + 20
+    "delayed_voting",  # last_regular + 21
+    "consolidate_treasury_balance",  # last_regular + 22
+    "effective_comment_vote",  # last_regular + 23
+    "ineffective_delete_comment",  # last_regular + 24
+    "sps_convert",  # last_regular + 25
+    "expired_account_notification",  # last_regular + 26
+    "changed_recovery_account",  # last_regular + 27
+    "transfer_to_vesting_completed",  # last_regular + 28
+    "pow_reward",  # last_regular + 29
+    "vesting_shares_split",  # last_regular + 30
+    "account_created",  # last_regular + 31
+    "fill_collateralized_convert_request",  # last_regular + 32
+    "system_warning",  # last_regular + 33,
+    "fill_recurrent_transfer",  # last_regular + 34
+    "failed_recurrent_transfer",  # last_regular + 35
+]
+
+operations: Dict[str, int] = {o: ops.index(o) for o in ops}
+
+
+def getOperationNameForId(i: int) -> str:
+    """Convert an operation id into the corresponding string"""
+    for key in operations:
+        if operations[key] == i:
+            return key
+    return "Unknown Operation ID %d" % i