hive-nectar 0.0.2__py3-none-any.whl

nectarapi/node.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+import logging
+import re
+import time
+
+from .exceptions import CallRetriesReached, NumRetriesReached
+
+log = logging.getLogger(__name__)
+
+
+class Node(object):
+    def __init__(self, url):
+        self.url = url
+        self.error_cnt = 0
+        self.error_cnt_call = 0
+
+    def __repr__(self):
+        return self.url
+
+
+class Nodes(list):
+    """Stores Node URLs and error counts"""
+
+    def __init__(self, urls, num_retries, num_retries_call):
+        self.set_node_urls(urls)
+        self.num_retries = num_retries
+        self.num_retries_call = num_retries_call
+
+    def set_node_urls(self, urls):
+        if isinstance(urls, str):
+            url_list = re.split(r",|;", urls)
+            if url_list is None:
+                url_list = [urls]
+        elif isinstance(urls, Nodes):
+            url_list = [urls[i].url for i in range(len(urls))]
+        elif isinstance(urls, (list, tuple, set)):
+            url_list = urls
+        elif urls is not None:
+            url_list = [urls]
+        else:
+            url_list = []
+        super(Nodes, self).__init__([Node(x) for x in url_list])
+        self.current_node_index = -1
+        self.freeze_current_node = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        next_node_count = 0
+        if self.freeze_current_node:
+            return self.url
+        while next_node_count == 0 and (
+            self.num_retries < 0 or self.node.error_cnt < self.num_retries
+        ):
+            self.current_node_index += 1
+            if self.current_node_index >= self.working_nodes_count:
+                self.current_node_index = 0
+            next_node_count += 1
+            if next_node_count > self.working_nodes_count + 1:
+                raise StopIteration
+        return self.url
+
+    next = __next__  # Python 2
+
+    def export_working_nodes(self):
+        nodes_list = []
+        for i in range(len(self)):
+            if self.num_retries < 0 or self[i].error_cnt <= self.num_retries:
+                nodes_list.append(self[i].url)
+        return nodes_list
+
+    def __repr__(self):
+        nodes_list = self.export_working_nodes()
+        return str(nodes_list)
+
+    @property
+    def working_nodes_count(self):
+        n = 0
+        if self.freeze_current_node:
+            i = self.current_node_index
+            if self.current_node_index < 0:
+                i = 0
+            if self.num_retries < 0 or self[i].error_cnt <= self.num_retries:
+                n += 1
+            return n
+        for i in range(len(self)):
+            if self.num_retries < 0 or self[i].error_cnt <= self.num_retries:
+                n += 1
+        return n
+
+    @property
+    def url(self):
+        if self.node is None:
+            return ""
+        return self.node.url
+
+    @property
+    def node(self):
+        if self.current_node_index < 0:
+            return self[0]
+        return self[self.current_node_index]
+
+    @property
+    def error_cnt(self):
+        if self.node is None:
+            return 0
+        return self.node.error_cnt
+
+    @property
+    def error_cnt_call(self):
+        if self.node is None:
+            return 0
+        return self.node.error_cnt_call
+
+    @property
+    def num_retries_call_reached(self):
+        return self.error_cnt_call >= self.num_retries_call
+
+    def disable_node(self):
+        """Disable current node"""
+        if self.node is not None and self.num_retries_call >= 0:
+            self.node.error_cnt_call = self.num_retries_call
+
+    def increase_error_cnt(self):
+        """Increase node error count for current node"""
+        if self.node is not None:
+            self.node.error_cnt += 1
+
+    def increase_error_cnt_call(self):
+        """Increase call error count for current node"""
+        if self.node is not None:
+            self.node.error_cnt_call += 1
+
+    def reset_error_cnt_call(self):
+        """Set call error count for current node to zero"""
+        if self.node is not None:
+            self.node.error_cnt_call = 0
+
+    def reset_error_cnt(self):
+        """Set node error count for current node to zero"""
+        if self.node is not None:
+            self.node.error_cnt = 0
+
+    def sleep_and_check_retries(self, errorMsg=None, sleep=True, call_retry=False, showMsg=True):
+        """Sleep and check if num_retries is reached"""
+        if errorMsg:
+            log.warning("Error: {}".format(errorMsg))
+        if call_retry:
+            cnt = self.error_cnt_call
+            if self.num_retries_call >= 0 and self.error_cnt_call > self.num_retries_call:
+                raise CallRetriesReached()
+        else:
+            cnt = self.error_cnt
+            if self.num_retries >= 0 and self.error_cnt > self.num_retries:
+                raise NumRetriesReached()
+
+        if showMsg:
+            if call_retry:
+                log.warning(
+                    "Retry RPC Call on node: %s (%d/%d) \n" % (self.url, cnt, self.num_retries_call)
+                )
+            else:
+                log.warning(
+                    "Lost connection or internal error on node: %s (%d/%d) \n"
+                    % (self.url, cnt, self.num_retries)
+                )
+        if not sleep:
+            return
+        if cnt < 1:
+            sleeptime = 0
+        elif cnt < 10:
+            sleeptime = (cnt - 1) * 1.5 + 0.5
+        else:
+            sleeptime = 10
+        if sleeptime:
+            log.warning("Retrying in %d seconds\n" % sleeptime)
+            time.sleep(sleeptime)

nectarapi/noderpc.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+import logging
+import re
+
+from . import exceptions
+from .graphenerpc import GrapheneRPC
+
+log = logging.getLogger(__name__)
+
+
+class NodeRPC(GrapheneRPC):
+    """This class allows to call API methods exposed by the witness node via
+    websockets / rpc-json.
+
+    :param str urls: Either a single Websocket/Http URL, or a list of URLs
+    :param str user: Username for Authentication
+    :param str password: Password for Authentication
+    :param int num_retries: Try x times to num_retries to a node on disconnect, -1 for indefinitely
+    :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)
+    :param int timeout: Timeout setting for https nodes (default is 60)
+    :param bool use_condenser: Use the old condenser_api rpc protocol on nodes with version
+        0.19.4 or higher. The settings has no effect on nodes with version of 0.19.3 or lower.
+    :param bool use_tor: When set to true, 'socks5h://localhost:9050' is set as proxy
+
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Init NodeRPC
+
+        :param str urls: Either a single Websocket/Http URL, or a list of URLs
+        :param str user: Username for Authentication
+        :param str password: Password for Authentication
+        :param int num_retries: Try x times to num_retries to a node on disconnect, -1 for indefinitely
+        :param int num_retries_call: Repeat num_retries_call times a rpc call on node error (default is 5)
+        :param int timeout: Timeout setting for https nodes (default is 60)
+        :param bool use_tor: When set to true, 'socks5h://localhost:9050' is set as proxy
+
+        """
+        super(NodeRPC, self).__init__(*args, **kwargs)
+        self.next_node_on_empty_reply = False
+
+    def set_next_node_on_empty_reply(self, next_node_on_empty_reply=True):
+        """Switch to next node on empty reply for the next rpc call"""
+        self.next_node_on_empty_reply = next_node_on_empty_reply
+
+    def rpcexec(self, payload):
+        """Execute a call by sending the payload.
+        It makes use of the GrapheneRPC library.
+        In here, we mostly deal with Steem specific error handling
+
+        :param json payload: Payload data
+        :raises ValueError: if the server does not respond in proper JSON format
+        :raises RPCError: if the server returns an error
+        """
+        if self.url is None:
+            raise exceptions.RPCConnection("RPC is not connected!")
+        doRetry = True
+        maxRetryCountReached = False
+        while doRetry and not maxRetryCountReached:
+            doRetry = False
+            try:
+                # Forward call to GrapheneWebsocketRPC and catch+evaluate errors
+                reply = super(NodeRPC, self).rpcexec(payload)
+                if (
+                    self.next_node_on_empty_reply
+                    and not bool(reply)
+                    and self.nodes.working_nodes_count > 1
+                ):
+                    self._retry_on_next_node("Empty Reply")
+                    doRetry = True
+                    self.next_node_on_empty_reply = True
+                else:
+                    self.next_node_on_empty_reply = False
+                    return reply
+            except exceptions.RPCErrorDoRetry as e:
+                msg = exceptions.decodeRPCErrorMsg(e).strip()
+                try:
+                    self.nodes.sleep_and_check_retries(str(msg), call_retry=True)
+                    doRetry = True
+                except exceptions.CallRetriesReached:
+                    if self.nodes.working_nodes_count > 1:
+                        self._retry_on_next_node(msg)
+                        doRetry = True
+                    else:
+                        self.next_node_on_empty_reply = False
+                        raise exceptions.CallRetriesReached
+            except exceptions.RPCError as e:
+                try:
+                    doRetry = self._check_error_message(e, self.error_cnt_call)
+                except exceptions.CallRetriesReached:
+                    msg = exceptions.decodeRPCErrorMsg(e).strip()
+                    if self.nodes.working_nodes_count > 1:
+                        self._retry_on_next_node(msg)
+                        doRetry = True
+                    else:
+                        self.next_node_on_empty_reply = False
+                        raise exceptions.CallRetriesReached
+            except Exception as e:
+                self.next_node_on_empty_reply = False
+                raise e
+            maxRetryCountReached = self.nodes.num_retries_call_reached
+        self.next_node_on_empty_reply = False
+
+    def _retry_on_next_node(self, error_msg):
+        self.nodes.increase_error_cnt()
+        self.nodes.sleep_and_check_retries(error_msg, sleep=False, call_retry=False)
+        self.next()
+
+    def _check_error_message(self, e, cnt):
+        """Check error message and decide what to do"""
+        doRetry = False
+        msg = exceptions.decodeRPCErrorMsg(e).strip()
+        if re.search("missing required active authority", msg):
+            raise exceptions.MissingRequiredActiveAuthority
+        elif re.match("^no method with name.*", msg):
+            raise exceptions.NoMethodWithName(msg)
+        elif re.search("Could not find method", msg):
+            raise exceptions.NoMethodWithName(msg)
+        elif re.search("Unknown Transaction", msg):
+            raise exceptions.UnknownTransaction(msg)
+        elif re.search("Could not find API", msg):
+            if self._check_api_name(msg):
+                if self.nodes.working_nodes_count > 1 and self.nodes.num_retries > -1:
+                    self.nodes.disable_node()
+                    self._switch_to_next_node(msg, "ApiNotSupported")
+                    doRetry = True
+                else:
+                    raise exceptions.ApiNotSupported(msg)
+            else:
+                raise exceptions.NoApiWithName(msg)
+        elif re.search("follow_api_plugin not enabled", msg):
+            if self.nodes.working_nodes_count > 1 and self.nodes.num_retries > -1:
+                self._switch_to_next_node(str(e))
+                doRetry = True
+            else:
+                raise exceptions.FollowApiNotEnabled(msg)
+        elif re.search("irrelevant signature included", msg):
+            raise exceptions.UnnecessarySignatureDetected(msg)
+        elif re.search("WinError", msg):
+            raise exceptions.RPCError(msg)
+        elif re.search("Invalid parameters", msg):
+            raise exceptions.InvalidParameters()
+        elif re.search("Supported by Hivemind", msg):
+            raise exceptions.SupportedByHivemind()
+        elif re.search("Could not find filtered operation", msg):
+            raise exceptions.FilteredItemNotFound(msg)
+        elif re.search("Unable to acquire database lock", msg):
+            self.nodes.sleep_and_check_retries(str(msg), call_retry=True)
+            doRetry = True
+        elif re.search("Request Timeout", msg):
+            self.nodes.sleep_and_check_retries(str(msg), call_retry=True)
+            doRetry = True
+        elif re.search("Bad or missing upstream response", msg):
+            self.nodes.sleep_and_check_retries(str(msg), call_retry=True)
+            doRetry = True
+        elif re.search("Internal Error", msg) or re.search("Unknown exception", msg):
+            self.nodes.sleep_and_check_retries(str(msg), call_retry=True)
+            doRetry = True
+        elif re.search("!check_max_block_age", str(e)):
+            self._switch_to_next_node(str(e))
+            doRetry = True
+        elif re.search("Server error", str(e)):
+            self._switch_to_next_node(str(e))
+            doRetry = True
+        elif re.search("Can only vote once every 3 seconds", msg):
+            raise exceptions.VotedBeforeWaitTimeReached(msg)
+        elif re.search("out_of_rangeEEEE: unknown key", msg) or re.search(
+            "unknown key:unknown key", msg
+        ):
+            raise exceptions.UnkownKey(msg)
+        elif re.search("Assert Exception:v.is_object(): Input data have to treated as object", msg):
+            raise exceptions.UnhandledRPCError(
+                "Use Operation(op, appbase=True) to prevent error: " + msg
+            )
+        elif re.search("Client returned invalid format. Expected JSON!", msg):
+            if self.nodes.working_nodes_count > 1 and self.nodes.num_retries > -1:
+                self.nodes.disable_node()
+                self._switch_to_next_node(msg)
+                doRetry = True
+            else:
+                raise exceptions.UnhandledRPCError(msg)
+        elif msg:
+            raise exceptions.UnhandledRPCError(msg)
+        else:
+            raise e
+        return doRetry
+
+    def _switch_to_next_node(self, msg, error_type="UnhandledRPCError"):
+        if self.nodes.working_nodes_count == 1:
+            if error_type == "UnhandledRPCError":
+                raise exceptions.UnhandledRPCError(msg)
+            elif error_type == "ApiNotSupported":
+                raise exceptions.ApiNotSupported(msg)
+        self.nodes.increase_error_cnt()
+        self.nodes.sleep_and_check_retries(str(msg), sleep=False)
+        self.next()
+
+    def _check_api_name(self, msg):
+        error_start = "Could not find API"
+        known_apis = [
+            "account_history_api",
+            "tags_api",
+            "database_api",
+            "market_history_api",
+            "block_api",
+            "account_by_key_api",
+            "chain_api",
+            "follow_api",
+            "condenser_api",
+            "debug_node_api",
+            "witness_api",
+            "test_api",
+            "bridge",
+            "network_broadcast_api",
+        ]
+        for api in known_apis:
+            if re.search(error_start + " " + api, msg):
+                return True
+        if msg[-18:] == error_start:
+            return True
+        return False
+
+    def get_account(self, name, **kwargs):
+        """Get full account details from account name
+
+        :param str name: Account name
+        """
+        if isinstance(name, str):
+            return self.get_accounts([name], **kwargs)

nectarapi/rpcutils.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+import json
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def is_network_appbase_ready(props):
+    """Checks if the network is appbase ready"""
+    if "STEEMIT_BLOCKCHAIN_VERSION" in props:
+        return False
+    elif "STEEM_BLOCKCHAIN_VERSION" in props:
+        return True
+    elif "HIVE_BLOCKCHAIN_VERSION" in props:
+        return True
+    else:
+        return False
+
+
+def get_query(appbase, request_id, api_name, name, args):
+    query = []
+    if not appbase or api_name == "condenser_api":
+        query = {
+            "method": "call",
+            "params": [api_name, name, list(args)],
+            "jsonrpc": "2.0",
+            "id": request_id,
+        }
+    else:
+        args = json.loads(json.dumps(args))
+        # print(args)
+        if len(args) > 0 and isinstance(args, list) and isinstance(args[0], dict):
+            query = {
+                "method": api_name + "." + name,
+                "params": args[0],
+                "jsonrpc": "2.0",
+                "id": request_id,
+            }
+        elif (
+            len(args) > 0
+            and isinstance(args, list)
+            and isinstance(args[0], list)
+            and len(args[0]) > 0
+            and isinstance(args[0][0], dict)
+        ):
+            for a in args[0]:
+                query.append(
+                    {
+                        "method": api_name + "." + name,
+                        "params": a,
+                        "jsonrpc": "2.0",
+                        "id": request_id,
+                    }
+                )
+                request_id += 1
+        elif args:
+            query = {
+                "method": "call",
+                "params": [api_name, name, list(args)],
+                "jsonrpc": "2.0",
+                "id": request_id,
+            }
+            request_id += 1
+        elif api_name == "condenser_api":
+            query = {
+                "method": api_name + "." + name,
+                "jsonrpc": "2.0",
+                "params": [],
+                "id": request_id,
+            }
+        else:
+            query = {
+                "method": api_name + "." + name,
+                "jsonrpc": "2.0",
+                "params": {},
+                "id": request_id,
+            }
+    return query
+
+
+def get_api_name(appbase, *args, **kwargs):
+    if not appbase:
+        # Sepcify the api to talk to
+        if ("api" in kwargs) and len(kwargs["api"]) > 0:
+            api_name = kwargs["api"].replace("_api", "") + "_api"
+        else:
+            api_name = None
+    else:
+        # Sepcify the api to talk to
+        if ("api" in kwargs) and len(kwargs["api"]) > 0:
+            if kwargs["api"] not in ["jsonrpc", "hive", "bridge"]:
+                api_name = kwargs["api"].replace("_api", "") + "_api"
+            else:
+                api_name = kwargs["api"]
+        else:
+            api_name = "condenser_api"
+    return api_name

nectarapi/version.py

@@ -0,0 +1,2 @@
+"""THIS FILE IS GENERATED FROM nectar PYPROJECT.TOML."""
+version = '0.00.02'

nectarbase/__init__.py

@@ -0,0 +1,14 @@
+"""nectarbase."""
+
+from .version import version as __version__
+
+__all__ = [
+    "memo",
+    "objects",
+    "objecttypes",
+    "operationids",
+    "operations",
+    "signedtransactions",
+    "ledgertransactions",
+    "transactions",
+]

nectarbase/ledgertransactions.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+import logging
+
+from nectargraphenebase.account import PublicKey
+from nectargraphenebase.chains import known_chains
+from nectargraphenebase.py23 import py23_bytes
+from nectargraphenebase.types import (
+    Array,
+    Signature,
+)
+from nectargraphenebase.unsignedtransactions import (
+    Unsigned_Transaction as GrapheneUnsigned_Transaction,
+)
+
+from .operations import Operation
+
+log = logging.getLogger(__name__)
+
+
+class Ledger_Transaction(GrapheneUnsigned_Transaction):
+    """Create an unsigned transaction and offer method to send it to a ledger device for signing
+
+    :param num ref_block_num:
+    :param num ref_block_prefix:
+    :param str expiration: expiration date
+    :param array operations:  array of operations
+    :param dict custom_chains: custom chain which should be added to the known chains
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.known_chains = known_chains
+        custom_chain = kwargs.get("custom_chains", {})
+        if len(custom_chain) > 0:
+            for c in custom_chain:
+                if c not in self.known_chains:
+                    self.known_chains[c] = custom_chain[c]
+        super(Ledger_Transaction, self).__init__(*args, **kwargs)
+
+    def add_custom_chains(self, custom_chain):
+        if len(custom_chain) > 0:
+            for c in custom_chain:
+                if c not in self.known_chains:
+                    self.known_chains[c] = custom_chain[c]
+
+    def getOperationKlass(self):
+        return Operation
+
+    def getKnownChains(self):
+        return self.known_chains
+
+    def sign(self, path="48'/13'/0'/0'/0'", chain="STEEM"):
+        from ledgerblue.comm import getDongle
+
+        dongle = getDongle(True)
+        apdu_list = self.build_apdu(path, chain)
+        for apdu in apdu_list:
+            result = dongle.exchange(py23_bytes(apdu))
+        dongle.close()
+        sigs = []
+        signature = result
+        sigs.append(Signature(signature))
+        self.data["signatures"] = Array(sigs)
+        return self
+
+    def get_pubkey(self, path="48'/13'/0'/0'/0'", request_screen_approval=False, prefix="STM"):
+        from ledgerblue.comm import getDongle
+
+        dongle = getDongle(True)
+        apdu = self.build_apdu_pubkey(path, request_screen_approval)
+        result = dongle.exchange(py23_bytes(apdu))
+        dongle.close()
+        offset = 1 + result[0]
+        address = result[offset + 1 : offset + 1 + result[offset]]
+        # public_key = result[1: 1 + result[0]]
+        return PublicKey(address.decode(), prefix=prefix)