hive-nectar 0.2.9__py3-none-any.whl

nectar/message.py

@@ -0,0 +1,379 @@
+import json
+import logging
+import re
+from binascii import hexlify, unhexlify
+from datetime import datetime, timezone
+from typing import Any, Optional, Union
+
+from nectar.account import Account
+from nectar.instance import shared_blockchain_instance
+from nectargraphenebase.account import PublicKey
+from nectargraphenebase.ecdsasig import sign_message, verify_message
+
+from .exceptions import (
+    AccountDoesNotExistsException,
+    InvalidMemoKeyException,
+    InvalidMessageSignature,
+    WrongMemoKey,
+)
+
+log = logging.getLogger(__name__)
+
+
+class MessageV1:
+    """Allow to sign and verify Messages that are sigend with a private key"""
+
+    MESSAGE_SPLIT = (
+        "-----BEGIN HIVE SIGNED MESSAGE-----",
+        "-----BEGIN META-----",
+        "-----BEGIN SIGNATURE-----",
+        "-----END HIVE SIGNED MESSAGE-----",
+    )
+
+    # This is the message that is actually signed
+    SIGNED_MESSAGE_META = """{message}
+account={meta[account]}
+memokey={meta[memokey]}
+block={meta[block]}
+timestamp={meta[timestamp]}"""
+
+    SIGNED_MESSAGE_ENCAPSULATED = """
+{MESSAGE_SPLIT[0]}
+{message}
+{MESSAGE_SPLIT[1]}
+account={meta[account]}
+memokey={meta[memokey]}
+block={meta[block]}
+timestamp={meta[timestamp]}
+{MESSAGE_SPLIT[2]}
+{signature}
+{MESSAGE_SPLIT[3]}"""
+
+    def __init__(
+        self, message: str, blockchain_instance: Optional[Any] = None, *args: Any, **kwargs: Any
+    ) -> None:
+        """
+        Initialize the message handler, normalize line endings, and set up signing context.
+
+        Parameters:
+            message (str): The raw message text to be signed or verified. Line endings are normalized to LF.
+
+        Description:
+            - Assigns self.blockchain to the provided blockchain_instance or to shared_blockchain_instance() when none is given.
+            - Normalizes CRLF ("\r\n") to LF ("\n") and stores the result in self.message.
+            - Initializes signing/verification context attributes: signed_by_account, signed_by_name, meta, and plain_message to None.
+        """
+        self.blockchain = blockchain_instance or shared_blockchain_instance()
+        self.message = message.replace("\r\n", "\n")
+        self.signed_by_account = None
+        self.signed_by_name = None
+        self.meta = None
+        self.plain_message = None
+
+    def sign(self, account: Optional[Union[str, Account]] = None, **kwargs: Any) -> Any:
+        """Sign a message with an account's memo key
+        :param str account: (optional) the account that owns the bet
+            (defaults to ``default_account``)
+        :raises ValueError: If not account for signing is provided
+        :returns: the signed message encapsulated in a known format
+        """
+        if not account:
+            if "default_account" in self.blockchain.config:
+                account = self.blockchain.config["default_account"]
+        if not account:
+            raise ValueError("You need to provide an account")
+
+        # Data for message
+        account = Account(account, blockchain_instance=self.blockchain)
+        info = self.blockchain.info()
+        meta = dict(
+            timestamp=info["time"],
+            block=info["head_block_number"],
+            memokey=account["memo_key"],
+            account=account["name"],
+        )
+
+        # wif key
+        wif = self.blockchain.wallet.getPrivateKeyForPublicKey(account["memo_key"])
+
+        # We strip the message here so we know for sure there are no trailing
+        # whitespaces or returns
+        message = self.message.strip()
+
+        enc_message = self.SIGNED_MESSAGE_META.format(**locals())
+
+        # signature
+        signature = hexlify(sign_message(enc_message, wif)).decode("ascii")
+
+        self.signed_by_account = account
+        self.signed_by_name = account["name"]
+        self.meta = meta
+        self.plain_message = message
+
+        return self.SIGNED_MESSAGE_ENCAPSULATED.format(MESSAGE_SPLIT=self.MESSAGE_SPLIT, **locals())
+
+    def verify(self, **kwargs: Any) -> bool:
+        """Verify a message with an account's memo key
+        :param str account: (optional) the account that owns the bet
+            (defaults to ``default_account``)
+        :returns: True if the message is verified successfully
+        :raises InvalidMessageSignature if the signature is not ok
+        """
+        # Split message into its parts
+        parts = re.split("|".join(self.MESSAGE_SPLIT), self.message)
+        parts = [x for x in parts if x.strip()]
+
+        assert len(parts) > 2, "Incorrect number of message parts"
+
+        # Strip away all whitespaces before and after the message
+        message = parts[0].strip()
+        signature = parts[2].strip()
+        # Parse the meta data
+        meta = dict(re.findall(r"(\S+)=(.*)", parts[1]))
+
+        log.info(f"Message is: {message}")
+        log.info(f"Meta is: {json.dumps(meta)}")
+        log.info(f"Signature is: {signature}")
+
+        # Ensure we have all the data in meta
+        assert "account" in meta, "No 'account' could be found in meta data"
+        assert "memokey" in meta, "No 'memokey' could be found in meta data"
+        assert "block" in meta, "No 'block' could be found in meta data"
+        assert "timestamp" in meta, "No 'timestamp' could be found in meta data"
+
+        account_name = meta.get("account", "").strip()
+        memo_key = meta.get("memokey", "").strip()
+
+        try:
+            PublicKey(memo_key, prefix=self.blockchain.prefix)
+        except Exception:
+            raise InvalidMemoKeyException("The memo key in the message is invalid")
+
+        # Load account from blockchain
+        try:
+            account = Account(account_name, blockchain_instance=self.blockchain)
+        except AccountDoesNotExistsException:
+            raise AccountDoesNotExistsException(
+                "Could not find account {}. Are you connected to the right chain?".format(
+                    account_name
+                )
+            )
+
+        # Test if memo key is the same as on the blockchain
+        if not account["memo_key"] == memo_key:
+            raise WrongMemoKey(
+                "Memo Key of account {} on the Blockchain ".format(account["name"])
+                + "differs from memo key in the message: {} != {}".format(
+                    account["memo_key"], memo_key
+                )
+            )
+
+        # Reformat message
+        enc_message = self.SIGNED_MESSAGE_META.format(**locals())
+
+        # Verify Signature
+        pubkey = verify_message(enc_message, unhexlify(signature))
+        if pubkey is None:
+            raise InvalidMessageSignature("No public key recovered from signature")
+
+        # Verify pubky
+        pk = PublicKey(hexlify(pubkey).decode("ascii"), prefix=self.blockchain.prefix)
+        if format(pk, self.blockchain.prefix) != memo_key:
+            raise InvalidMessageSignature("The signature doesn't match the memo key")
+
+        self.signed_by_account = account
+        self.signed_by_name = account["name"]
+        self.meta = meta
+        self.plain_message = message
+
+        return True
+
+
+class MessageV2:
+    """Allow to sign and verify Messages that are sigend with a private key"""
+
+    def __init__(
+        self, message: str, blockchain_instance: Optional[Any] = None, *args: Any, **kwargs: Any
+    ) -> None:
+        """
+        Initialize the message handler and set up default signing context.
+
+        Parameters:
+            message (str): The raw message text to be signed or verified.
+
+        Description:
+            Stores the provided message and sets up the signing context attributes
+            (signed_by_account, signed_by_name, meta, plain_message) to None.
+            If no blockchain instance is supplied, assigns a shared blockchain instance
+            via shared_blockchain_instance().
+        """
+        self.blockchain = blockchain_instance or shared_blockchain_instance()
+
+        self.message = message
+        self.signed_by_account = None
+        self.signed_by_name = None
+        self.meta = None
+        self.plain_message = None
+
+    def sign(self, account: Optional[Union[str, Account]] = None, **kwargs: Any) -> Any:
+        """Sign a message with an account's memo key
+        :param str account: (optional) the account that owns the bet
+            (defaults to ``default_account``)
+        :raises ValueError: If not account for signing is provided
+        :returns: the signed message encapsulated in a known format
+        """
+        if not account:
+            if "default_account" in self.blockchain.config:
+                account = self.blockchain.config["default_account"]
+        if not account:
+            raise ValueError("You need to provide an account")
+
+        # Data for message
+        account = Account(account, blockchain_instance=self.blockchain)
+
+        # wif key
+        wif = self.blockchain.wallet.getPrivateKeyForPublicKey(account["memo_key"])
+
+        payload = [
+            "from",
+            account["name"],
+            "key",
+            account["memo_key"],
+            "time",
+            str(datetime.now(timezone.utc)),
+            "text",
+            self.message,
+        ]
+        enc_message = json.dumps(payload, separators=(",", ":"))
+
+        # signature
+        signature = hexlify(sign_message(enc_message, wif)).decode("ascii")
+
+        return dict(signed=enc_message, payload=payload, signature=signature)
+
+    def verify(self, **kwargs: Any) -> bool:
+        """Verify a message with an account's memo key
+        :param str account: (optional) the account that owns the bet
+            (defaults to ``default_account``)
+        :returns: True if the message is verified successfully
+        :raises InvalidMessageSignature if the signature is not ok
+        """
+        if not isinstance(self.message, dict):
+            try:
+                self.message = json.loads(self.message)
+            except Exception:
+                raise ValueError("Message must be valid JSON")
+
+        payload = self.message.get("payload")
+        assert payload, "Missing payload"
+        payload_dict = {k[0]: k[1] for k in zip(payload[::2], payload[1::2])}
+        signature = self.message.get("signature")
+
+        account_name = payload_dict.get("from", "").strip()
+        memo_key = payload_dict.get("key", "").strip()
+
+        assert account_name, "Missing account name 'from'"
+        assert memo_key, "missing 'key'"
+
+        try:
+            # Validate that the memo key is a syntactically valid public key
+            PublicKey(memo_key, prefix=self.blockchain.prefix)
+        except Exception:
+            raise InvalidMemoKeyException("The memo key in the message is invalid")
+
+        # Load account from blockchain
+        try:
+            account = Account(account_name, blockchain_instance=self.blockchain)
+        except AccountDoesNotExistsException:
+            raise AccountDoesNotExistsException(
+                "Could not find account {}. Are you connected to the right chain?".format(
+                    account_name
+                )
+            )
+
+        # Test if memo key is the same as on the blockchain
+        if not account["memo_key"] == memo_key:
+            raise WrongMemoKey(
+                "Memo Key of account {} on the Blockchain ".format(account["name"])
+                + "differs from memo key in the message: {} != {}".format(
+                    account["memo_key"], memo_key
+                )
+            )
+
+        # Ensure payload and signed match
+        signed_target = json.dumps(self.message.get("payload"), separators=(",", ":"))
+        signed_actual = self.message.get("signed")
+        assert signed_target == signed_actual, (
+            "payload doesn't match signed message: \n{}\n{}".format(signed_target, signed_actual)
+        )
+
+        # Reformat message
+        enc_message = self.message.get("signed")
+
+        # Verify Signature
+        pubkey = verify_message(enc_message, unhexlify(signature))
+
+        # Verify pubky
+        if pubkey is None:
+            raise InvalidMessageSignature("No public key recovered from signature")
+        pk = PublicKey(hexlify(pubkey).decode("ascii"), prefix=self.blockchain.prefix)
+        if format(pk, self.blockchain.prefix) != memo_key:
+            raise InvalidMessageSignature("The signature doesn't match the memo key")
+
+        self.signed_by_account = account
+        self.signed_by_name = account["name"]
+        self.plain_message = payload_dict.get("text")
+
+        return True
+
+
+class Message(MessageV1, MessageV2):
+    supported_formats = (MessageV1, MessageV2)
+    valid_exceptions = (
+        AccountDoesNotExistsException,
+        InvalidMessageSignature,
+        WrongMemoKey,
+        InvalidMemoKeyException,
+    )
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        for _format in self.supported_formats:
+            try:
+                _format.__init__(self, *args, **kwargs)
+                return
+            except self.valid_exceptions as e:
+                raise e
+            except Exception as e:
+                log.warning(
+                    "{}: Couldn't init: {}: {}".format(
+                        _format.__name__, e.__class__.__name__, str(e)
+                    )
+                )
+
+    def verify(self, **kwargs: Any) -> bool:
+        for _format in self.supported_formats:
+            try:
+                return _format.verify(self, **kwargs)
+            except self.valid_exceptions as e:
+                raise e
+            except Exception as e:
+                log.warning(
+                    "{}: Couldn't verify: {}: {}".format(
+                        _format.__name__, e.__class__.__name__, str(e)
+                    )
+                )
+        raise ValueError("No Decoder accepted the message")
+
+    def sign(self, account: Optional[Union[str, Account]] = None, **kwargs: Any) -> Any:
+        for _format in self.supported_formats:
+            try:
+                return _format.sign(self, account=account, **kwargs)
+            except self.valid_exceptions as e:
+                raise e
+            except Exception as e:
+                log.warning(
+                    "{}: Couldn't sign: {}: {}".format(
+                        _format.__name__, e.__class__.__name__, str(e)
+                    )
+                )
+        raise ValueError("No Decoder accepted the message")

nectar/nodelist.py

@@ -0,0 +1,309 @@
+import json
+import logging
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+log = logging.getLogger(__name__)
+
+# Static fallback nodes in case beacon is unavailable
+STATIC_NODES = [
+    "https://api.hive.blog",
+    "https://api.openhive.network",
+    "https://api.syncad.com",
+    "https://api.deathwing.me",
+    "https://api.c0ff33a.uk",
+    "https://hive-api.3speak.tv",
+    "https://hiveapi.actifit.io",
+    "https://rpc.mahdiyari.info",
+    "https://techcoderx.com",
+    "https://anyx.io",
+]
+
+BEACON_URL = "https://beacon.peakd.com/api/nodes"
+REQUEST_TIMEOUT = 10  # seconds
+CACHE_DURATION = 300  # 5 minutes cache
+
+# Global cache for node data
+_cached_nodes: Optional[List[Dict[str, Any]]] = None
+_cache_timestamp: float = 0
+_cache_lock = threading.Lock()
+
+
+def fetch_beacon_nodes() -> Optional[List[Dict[str, Any]]]:
+    """Fetch node list from PeakD beacon API with caching.
+
+    Returns:
+        List of node dictionaries from beacon API, or None if fetch fails
+    """
+    global _cached_nodes, _cache_timestamp
+
+    current_time = time.time()
+
+    # Return cached data if still valid
+    with _cache_lock:
+        if _cached_nodes is not None and current_time - _cache_timestamp < CACHE_DURATION:
+            log.debug("Using cached beacon nodes")
+            return _cached_nodes
+
+    try:
+        log.debug("Fetching fresh nodes from beacon API")
+        with httpx.Client(timeout=REQUEST_TIMEOUT) as client:
+            response = client.get(BEACON_URL, headers={"Accept": "*/*"})
+            response.raise_for_status()
+            nodes = response.json()
+
+            # Cache the successful result
+            with _cache_lock:
+                _cached_nodes = nodes
+                _cache_timestamp = current_time
+            return nodes
+    except (httpx.RequestError, httpx.HTTPStatusError, json.JSONDecodeError, Exception) as e:
+        log.warning(f"Failed to fetch nodes from beacon API: {e}")
+        # Return cached data even if expired, as fallback
+        with _cache_lock:
+            if _cached_nodes is not None:
+                log.info("Using expired cached nodes as fallback")
+                return _cached_nodes
+        return None
+
+
+def clear_beacon_cache() -> None:
+    """Clear the cached beacon node data.
+
+    This forces the next NodeList() instantiation or update_nodes() call
+    to fetch fresh data from the beacon API.
+    """
+    global _cached_nodes, _cache_timestamp
+    with _cache_lock:
+        _cached_nodes = None
+        _cache_timestamp = 0
+    log.debug("Beacon node cache cleared")
+
+
+class NodeList(list):
+    """Simplified Hive node list using PeakD beacon API.
+
+    Fetches real-time node information from PeakD beacon API with static fallback.
+
+    .. code-block:: python
+
+        from nectar.nodelist import NodeList
+        n = NodeList()
+        nodes_urls = n.get_nodes()
+    """
+
+    def __init__(self):
+        """Initialize NodeList with nodes from beacon API or static fallback."""
+        super().__init__()
+        self._refresh_nodes()
+
+    def _refresh_nodes(self) -> None:
+        """Refresh node list from beacon API or use static fallback."""
+        beacon_nodes = fetch_beacon_nodes()
+
+        if beacon_nodes:
+            # Convert beacon format to our internal format
+            nodes = []
+            for node in beacon_nodes:
+                # Only include nodes with decent performance (score > 0)
+                if node.get("score", 0) > 0:
+                    nodes.append(
+                        {
+                            "url": node["endpoint"],
+                            "version": node.get("version", "unknown"),
+                            "type": "appbase",  # All beacon nodes are appbase
+                            "owner": node.get("name", "unknown"),
+                            "hive": True,
+                            "score": node.get("score", 0),
+                        }
+                    )
+
+            # Sort by score (highest first)
+            nodes.sort(key=lambda x: x["score"], reverse=True)
+            super().__init__(nodes)
+            log.info(f"Loaded {len(nodes)} nodes from PeakD beacon API")
+        else:
+            # Use static fallback
+            nodes = [
+                {
+                    "url": url,
+                    "version": "unknown",
+                    "type": "appbase",
+                    "owner": "static",
+                    "hive": True,
+                    "score": 50,
+                }
+                for url in STATIC_NODES
+            ]
+            super().__init__(nodes)
+            log.warning(f"Using static fallback nodes ({len(nodes)} nodes)")
+
+    def get_nodes(
+        self,
+        hive: bool = True,
+        dev: bool = False,
+        testnet: bool = False,
+        testnetdev: bool = False,
+        wss: bool = True,
+        https: bool = True,
+        not_working: bool = False,
+        normal: bool = False,
+        appbase: bool = True,
+    ) -> List[str]:
+        """Return a list of node URLs filtered and sorted by score.
+
+        Args:
+            hive: Filter for Hive nodes only (default: True)
+            dev: Include dev nodes (not applicable with beacon)
+            testnet: Include testnet nodes (not applicable with beacon)
+            testnetdev: Include testnet dev nodes (not applicable with beacon)
+            wss: Include WebSocket nodes (default: True)
+            https: Include HTTPS nodes (default: True)
+            not_working: Include nodes with negative scores (default: False)
+            normal: Include normal nodes (deprecated, default: False)
+            appbase: Include appbase nodes (default: True)
+
+        Returns:
+            List of node URLs sorted by score (highest first)
+        """
+        filtered_nodes = []
+
+        # Determine allowed types based on flags (OR logic)
+        allowed_types = set()
+        if appbase:
+            allowed_types.add("appbase")
+        if normal:
+            allowed_types.add("normal")
+        if dev:
+            allowed_types.add("appbase-dev")
+        if testnet:
+            allowed_types.add("testnet")
+        if testnetdev:
+            allowed_types.add("testnet-dev")
+
+        for node in self:
+            # Filter by score
+            if node["score"] < 0 and not not_working:
+                continue
+
+            # Filter by Hive
+            if hive and not node["hive"]:
+                continue
+
+            # Filter by protocol
+            if not https and node["url"].startswith("https"):
+                continue
+            if not wss and node["url"].startswith("wss"):
+                continue
+
+            # Filter by type (OR logic)
+            if allowed_types and node["type"] not in allowed_types:
+                continue
+
+            filtered_nodes.append(node)
+
+        # Sort by score (highest first) and return URLs
+        filtered_nodes.sort(key=lambda x: x["score"], reverse=True)
+        return [node["url"] for node in filtered_nodes]
+
+    def get_hive_nodes(
+        self, testnet: bool = False, not_working: bool = False, wss: bool = True, https: bool = True
+    ) -> List[str]:
+        """Return a list of Hive node URLs filtered and ordered by score.
+
+        Args:
+            testnet: Include testnet nodes (default: False)
+            not_working: Include nodes with negative scores (default: False)
+            wss: Include WebSocket nodes (default: True)
+            https: Include HTTPS nodes (default: True)
+
+        Returns:
+            List of Hive node URLs sorted by score
+        """
+        return self.get_nodes(
+            hive=True,
+            testnet=testnet,
+            not_working=not_working,
+            wss=wss,
+            https=https,
+            appbase=True,
+            normal=False,
+        )
+
+    def get_testnet(self, testnet: bool = True, testnetdev: bool = False) -> List[str]:
+        """Return a list of testnet node URLs (currently unavailable).
+
+        Note: The PeakD beacon API does not provide testnet nodes. This method
+        currently returns an empty list. Use mainnet nodes for testing or
+        manually configure testnet endpoints.
+
+        Args:
+            testnet: Include testnet nodes (default: True)
+            testnetdev: Include testnet dev nodes (default: False)
+
+        Returns:
+            List of testnet node URLs
+        """
+        log.warning("Testnet nodes are not available from beacon API")
+        return self.get_nodes(
+            normal=False,
+            appbase=False,
+            testnet=testnet,
+            testnetdev=testnetdev,
+        )
+
+    def update_nodes(self, weights: Any = None, blockchain_instance: Any = None) -> None:
+        """Refresh nodes from beacon API.
+
+        This method replaces the complex update logic with a simple refresh
+        from the beacon API and clears the cache to force fresh data.
+
+        Args:
+            weights: Ignored (beacon provides its own scoring)
+            blockchain_instance: Ignored (beacon API is independent)
+        """
+        clear_beacon_cache()
+        self._refresh_nodes()
+
+    def update(self, node_list: List[str]) -> None:
+        """Update node list (not implemented with beacon API).
+
+        Args:
+            node_list: List of node URLs (ignored with beacon API)
+        """
+        log.info("NodeList.update() is deprecated with beacon API - using beacon data instead")
+        self._refresh_nodes()
+
+    def get_node_answer_time(
+        self, node_list: Optional[List[str]] = None, verbose: bool = False
+    ) -> List[Dict[str, float]]:
+        """Get node response times (deprecated with beacon API).
+
+        The beacon API already provides performance scoring, so this method
+        returns the beacon scores instead of measuring response times.
+
+        Args:
+            node_list: List of node URLs to check (ignored, uses all nodes)
+            verbose: Log node information (default: False)
+
+        Returns:
+            List of dictionaries with 'url' and 'delay_ms' keys
+        """
+        log.info("get_node_answer_time() using beacon scores instead of measuring response times")
+
+        result = []
+        for node in self:
+            # Convert beacon score (0-100) to a fake delay for compatibility
+            # Higher score = lower delay
+            fake_delay_ms = (100 - node["score"]) * 10  # Simple conversion
+            result.append({"url": node["url"], "delay_ms": fake_delay_ms})
+
+            if verbose:
+                log.info(
+                    f"node {node['url']} beacon score: {node['score']}, fake delay: {fake_delay_ms:.2f}ms"
+                )
+
+        return sorted(result, key=lambda x: x["delay_ms"])