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

nectar/market.py

@@ -29,9 +29,9 @@ log = logging.getLogger(__name__)
 
 
 class Market(dict):
-    """This class allows to easily access Markets on the blockchain for trading, etc.
+    """This class allows access to the internal market for trading, etc. (Hive-only).
 
-    :param Steem blockchain_instance: Steem instance
+    :param Hive blockchain_instance: Hive instance
     :param Asset base: Base asset
     :param Asset quote: Quote asset
     :returns: Blockchain Market
@@ -50,7 +50,7 @@ class Market(dict):
     * ``base-quote`` separated with ``-``
 
     .. note:: Throughout this library, the ``quote`` symbol will be
-              presented first (e.g. ``STEEM:SBD`` with ``STEEM`` being the
+              presented first (e.g. ``HIVE:HBD`` with ``HIVE`` being the
               quote), while the ``base`` only refers to a secondary asset
               for a trade. This means, if you call
               :func:`nectar.market.Market.sell` or
@@ -61,17 +61,18 @@ class Market(dict):
 
     def __init__(self, base=None, quote=None, blockchain_instance=None, **kwargs):
         """
-        Init Market
+        Create a Market mapping with "base" and "quote" Asset objects.
 
-            :param nectar.steem.Steem blockchain_instance: Steem instance
-            :param nectar.asset.Asset base: Base asset
-            :param nectar.asset.Asset quote: Quote asset
+        Supports three initialization modes:
+        - Single-string market identifier (e.g., "HBD:HIVE" or "HIVE:HBD"): parsed into quote and base symbols and converted to Asset objects.
+        - Explicit base and quote (either Asset instances or values accepted by Asset): each converted to an Asset.
+        - No arguments: uses the blockchain instance's default token symbols (token_symbol as base, backed_token_symbol as quote).
+
+        The resolved Asset objects are stored in the instance as entries "base" and "quote". The blockchain instance used is the provided one or the shared global instance.
+
+        Raises:
+            ValueError: if the combination of arguments does not match any supported initialization mode.
         """
-        if blockchain_instance is None:
-            if kwargs.get("steem_instance"):
-                blockchain_instance = kwargs["steem_instance"]
-            elif kwargs.get("hive_instance"):
-                blockchain_instance = kwargs["hive_instance"]
         self.blockchain = blockchain_instance or shared_blockchain_instance()
 
         if quote is None and isinstance(base, str):
@@ -97,9 +98,14 @@ class Market(dict):
             raise ValueError("Unknown Market config")
 
     def get_string(self, separator=":"):
-        """Return a formated string that identifies the market, e.g. ``STEEM:SBD``
+        """
+        Return the market identifier as "QUOTE{separator}BASE" (e.g. "HIVE:HBD").
+
+        Parameters:
+            separator (str): Token placed between quote and base symbols. Defaults to ":".
 
-        :param str separator: The separator of the assets (defaults to ``:``)
+        Returns:
+            str: Formatted market string in the form "<quote><separator><base>".
         """
         return "%s%s%s" % (self["quote"]["symbol"], separator, self["base"]["symbol"])
 
@@ -116,35 +122,21 @@ class Market(dict):
             )
 
     def ticker(self, raw_data=False):
-        """Returns the ticker for all markets.
-
-        Output Parameters:
-
-        * ``latest``: Price of the order last filled
-        * ``lowest_ask``: Price of the lowest ask
-        * ``highest_bid``: Price of the highest bid
-        * ``sbd_volume``: Volume of SBD
-        * ``steem_volume``: Volume of STEEM
-        * ``hbd_volume``: Volume of HBD
-        * ``hive_volume``: Volume of HIVE
-        * ``percent_change``: 24h change percentage (in %)
+        """
+        Return the market ticker for this Market (HIVE:HBD).
 
-        .. note::
-            Market is HIVE:HBD and prices are HBD per HIVE!
+        By default returns a dict with Price objects for 'highest_bid', 'latest', and 'lowest_ask',
+        a float 'percent_change' (24h), and Amount objects for 'hbd_volume' and 'hive_volume' when present.
+        If raw_data is True, returns the unprocessed RPC result.
 
-        Sample Output:
+        Parameters:
+            raw_data (bool): If True, return the raw market_history RPC response instead of mapped objects.
 
-        .. code-block:: js
-
-             {
-                'highest_bid': 0.30100226633322913,
-                'latest': 0.0,
-                'lowest_ask': 0.3249636958897082,
-                'percent_change': 0.0,
-                'sbd_volume': 108329611.0,
-                'steem_volume': 355094043.0
-            }
+        Returns:
+            dict or Any: Mapped ticker dictionary (prices as Price, volumes as Amount) or raw RPC data.
 
+        Notes:
+            Prices are expressed as HBD per HIVE.
         """
         data = {}
         # Core Exchange rate
@@ -173,46 +165,30 @@ class Market(dict):
             blockchain_instance=self.blockchain,
         )
         data["percent_change"] = float(ticker["percent_change"])
-        if "sbd_volume" in ticker:
-            data["sbd_volume"] = Amount(ticker["sbd_volume"], blockchain_instance=self.blockchain)
-        elif "hbd_volume" in ticker:
+        if "hbd_volume" in ticker:
             data["hbd_volume"] = Amount(ticker["hbd_volume"], blockchain_instance=self.blockchain)
-        if "steem_volume" in ticker:
-            data["steem_volume"] = Amount(
-                ticker["steem_volume"], blockchain_instance=self.blockchain
-            )
-        elif "hive_volume" in ticker:
+        if "hive_volume" in ticker:
             data["hive_volume"] = Amount(ticker["hive_volume"], blockchain_instance=self.blockchain)
 
         return data
 
     def volume24h(self, raw_data=False):
-        """Returns the 24-hour volume for all markets, plus totals for primary currencies.
-
-        Sample output:
-
-        .. code-block:: js
+        """
+        Return 24-hour trading volume for this market.
 
-            {
-                "STEEM": 361666.63617,
-                "SBD": 1087.0
-            }
+        If raw_data is True, returns the raw result from the blockchain `market_history` RPC.
+        Otherwise, if the RPC result contains 'hbd_volume' and 'hive_volume', returns a dict mapping
+        asset symbols to Amount objects, e.g. { "HBD": Amount(...), "HIVE": Amount(...) }.
+        If the expected volume keys are not present, returns None.
 
+        Parameters:
+            raw_data (bool): If True, return the unprocessed RPC response.
         """
         self.blockchain.rpc.set_next_node_on_empty_reply(True)
         volume = self.blockchain.rpc.get_volume(api="market_history")
         if raw_data:
             return volume
-        if "sbd_volume" in volume and "steem_volume" in volume:
-            return {
-                self["base"]["symbol"]: Amount(
-                    volume["sbd_volume"], blockchain_instance=self.blockchain
-                ),
-                self["quote"]["symbol"]: Amount(
-                    volume["steem_volume"], blockchain_instance=self.blockchain
-                ),
-            }
-        elif "hbd_volume" in volume and "hive_volume" in volume:
+        if "hbd_volume" in volume and "hive_volume" in volume:
             return {
                 self["base"]["symbol"]: Amount(
                     volume["hbd_volume"], blockchain_instance=self.blockchain
@@ -223,7 +199,7 @@ class Market(dict):
             }
 
     def orderbook(self, limit=25, raw_data=False):
-        """Returns the order book for SBD/STEEM market.
+        """Returns the order book for the HBD/HIVE market.
 
         :param int limit: Limit the amount of orders (default: 25)
 
@@ -233,12 +209,12 @@ class Market(dict):
 
                 {
                     'asks': [
-                        380.510 STEEM 460.291 SBD @ 1.209669 SBD/STEEM,
-                        53.785 STEEM 65.063 SBD @ 1.209687 SBD/STEEM
+                        380.510 HIVE 460.291 HBD @ 1.209669 HBD/HIVE,
+                        53.785 HIVE 65.063 HBD @ 1.209687 HBD/HIVE
                     ],
                     'bids': [
-                        0.292 STEEM 0.353 SBD @ 1.208904 SBD/STEEM,
-                        8.498 STEEM 10.262 SBD @ 1.207578 SBD/STEEM
+                        0.292 HIVE 0.353 HBD @ 1.208904 HBD/HIVE,
+                        8.498 HIVE 10.262 HBD @ 1.207578 HBD/HIVE
                     ],
                     'asks_date': [
                         datetime.datetime(2018, 4, 30, 21, 7, 24, tzinfo=<UTC>),
@@ -257,19 +233,19 @@ class Market(dict):
                 {
                     'asks': [
                         {
-                            'order_price': {'base': '8.000 STEEM', 'quote': '9.618 SBD'},
+                            'order_price': {'base': '8.000 HIVE', 'quote': '9.618 HBD'},
                             'real_price': '1.20225000000000004',
-                            'steem': 4565,
-                            'sbd': 5488,
+                            'hive': 4565,
+                            'hbd': 5488,
                             'created': '2018-04-30T21:12:45'
                         }
                     ],
                     'bids': [
                         {
-                            'order_price': {'base': '10.000 SBD', 'quote': '8.333 STEEM'},
+                            'order_price': {'base': '10.000 HBD', 'quote': '8.333 HIVE'},
                             'real_price': '1.20004800192007677',
-                            'steem': 8333,
-                            'sbd': 10000,
+                            'hive': 8333,
+                            'hbd': 10000,
                             'created': '2018-04-30T20:29:33'
                         }
                     ]
@@ -314,42 +290,17 @@ class Market(dict):
         return data
 
     def recent_trades(self, limit=25, raw_data=False):
-        """Returns the order book for a given market. You may also
-        specify "all" to get the orderbooks of all markets.
-
-        :param int limit: Limit the amount of orders (default: 25)
-        :param bool raw_data: when False, FilledOrder objects will be
-            returned
-
-        Sample output (raw_data=False):
-
-            .. code-block:: none
-
-                [
-                    (2018-04-30 21:00:54+00:00) 0.267 STEEM 0.323 SBD @ 1.209738 SBD/STEEM,
-                    (2018-04-30 20:59:30+00:00) 0.131 STEEM 0.159 SBD @ 1.213740 SBD/STEEM,
-                    (2018-04-30 20:55:45+00:00) 0.093 STEEM 0.113 SBD @ 1.215054 SBD/STEEM,
-                    (2018-04-30 20:55:30+00:00) 26.501 STEEM 32.058 SBD @ 1.209690 SBD/STEEM,
-                    (2018-04-30 20:55:18+00:00) 2.108 STEEM 2.550 SBD @ 1.209677 SBD/STEEM,
-                ]
-
-        Sample output (raw_data=True):
-
-            .. code-block:: js
+        """
+        Return recent trades for this market.
 
-                [
-                    {'date': '2018-04-30T21:02:45', 'current_pays': '0.235 SBD', 'open_pays': '0.194 STEEM'},
-                    {'date': '2018-04-30T21:02:03', 'current_pays': '24.494 SBD', 'open_pays': '20.248 STEEM'},
-                    {'date': '2018-04-30T20:48:30', 'current_pays': '175.464 STEEM', 'open_pays': '211.955 SBD'},
-                    {'date': '2018-04-30T20:48:30', 'current_pays': '0.999 STEEM', 'open_pays': '1.207 SBD'},
-                    {'date': '2018-04-30T20:47:54', 'current_pays': '0.273 SBD', 'open_pays': '0.225 STEEM'},
-                ]
+        By default returns up to `limit` most recent trades wrapped as FilledOrder objects; if `raw_data` is True the raw trade dictionaries from the market_history API are returned instead.
 
-        .. note:: Each bid is an instance of
-            :class:`nectar.price.Order` and thus carries the keys
-            ``base``, ``quote`` and ``price``. From those you can
-            obtain the actual amounts for sale
+        Parameters:
+            limit (int): Maximum number of trades to retrieve (default: 25).
+            raw_data (bool): If True, return raw API trade entries; if False, return a list of FilledOrder instances constructed with this market's blockchain instance.
 
+        Returns:
+            list: A list of FilledOrder objects when `raw_data` is False, or a list of raw trade dicts as returned by the market_history API when `raw_data` is True.
         """
         self.blockchain.rpc.set_next_node_on_empty_reply(limit > 0)
         if self.blockchain.rpc.get_use_appbase():
@@ -450,36 +401,22 @@ class Market(dict):
             return ret
 
     def market_history(self, bucket_seconds=300, start_age=3600, end_age=0, raw_data=False):
-        """Return the market history (filled orders).
+        """
+        Return market history buckets for a time window.
 
-        :param int bucket_seconds: Bucket size in seconds (see
-            `returnMarketHistoryBuckets()`)
-        :param int start_age: Age (in seconds) of the start of the
-            window (default: 1h/3600)
-        :param int end_age: Age (in seconds) of the end of the window
-            (default: now/0)
-        :param bool raw_data: (optional) returns raw data if set True
+        This fetches aggregated market history buckets (filled orders) for the market over a window defined by start_age and end_age and grouped by bucket_seconds. bucket_seconds may be provided either as a numeric bucket size (seconds) or as an index into available buckets returned by market_history_buckets(). When raw_data is False any bucket "open" timestamp strings are normalized to a consistent formatted datetime string.
 
-        Example:
+        Parameters:
+            bucket_seconds (int): Bucket size in seconds or an index into market_history_buckets().
+            start_age (int): Age in seconds from now to the start of the window (default 3600 seconds).
+            end_age (int): Age in seconds from now to the end of the window (default 0 = now).
+            raw_data (bool): If True, return the raw RPC response without normalizing timestamps.
 
-            .. code-block:: js
-
-                {
-                    'close_sbd': 2493387,
-                    'close_steem': 7743431,
-                    'high_sbd': 1943872,
-                    'high_steem': 5999610,
-                    'id': '7.1.5252',
-                    'low_sbd': 534928,
-                    'low_steem': 1661266,
-                    'open': '2016-07-08T11:25:00',
-                    'open_sbd': 534928,
-                    'open_steem': 1661266,
-                    'sbd_volume': 9714435,
-                    'seconds': 300,
-                    'steem_volume': 30088443
-                }
+        Returns:
+            list: A list of bucket dicts (or the raw RPC list when raw_data is True). Each bucket contains fields such as 'open', 'seconds', 'open_hbd', 'close_hbd', 'high_hbd', 'low_hbd', 'hbd_volume', 'open_hive', 'close_hive', 'high_hive', 'low_hive', 'hive_volume', and 'id' when available.
 
+        Raises:
+            ValueError: If bucket_seconds is not a valid bucket size or valid index into available buckets.
         """
         buckets = self.market_history_buckets()
         if bucket_seconds < 5 and bucket_seconds >= 0:
@@ -562,39 +499,29 @@ class Market(dict):
         orderid=None,
         returnOrderId=False,
     ):
-        """Places a buy order in a given market
-
-        :param float price: price denoted in ``base``/``quote``
-        :param number amount: Amount of ``quote`` to buy
-        :param number expiration: (optional) expiration time of the order in seconds (defaults to 7 days)
-        :param bool killfill: flag that indicates if the order shall be killed if it is not filled (defaults to False)
-        :param string account: Account name that executes that order
-        :param string returnOrderId: If set to "head" or "irreversible" the call will wait for the tx to appear in
-            the head/irreversible block and add the key "orderid" to the tx output
-
-        Prices/Rates are denoted in 'base', i.e. the SBD_STEEM market
-        is priced in STEEM per SBD.
-
-        **Example:** in the SBD_STEEM market, a price of 300 means
-        a SBD is worth 300 STEEM
+        """
+        Place a buy order (limit order) on this market.
 
-        .. note::
+        Prices are expressed in the market's base/quote orientation (HIVE per HBD in HBD_HIVE). This method submits a limit-order-create operation that effectively places a sell order of the base asset to acquire the requested amount of the quote asset.
 
-            All prices returned are in the **reversed** orientation as the
-            market. I.e. in the STEEM/SBD market, prices are SBD per STEEM.
-            That way you can multiply prices with `1.05` to get a +5%.
+        Parameters:
+            price (float or Price): Price expressed in base per quote (e.g., HIVE per HBD).
+            amount (number or str or Amount): Amount of the quote asset to buy.
+            expiration (int, optional): Order lifetime in seconds (default: configured order-expiration, typically 7 days).
+            killfill (bool, optional): If True, set fill_or_kill on the order (defaults to False).
+            account (str, optional): Account name that will own and broadcast the order. If omitted, default_account from config is used; a ValueError is raised if none is available.
+            orderid (int, optional): Explicit client-side order id. If omitted one is randomly generated.
+            returnOrderId (bool or str, optional): If truthy (or set to "head"/"irreversible"), the call will wait for the transaction and attach the assigned order id to the returned transaction under the "orderid" key.
 
-        .. warning::
+        Returns:
+            dict: The finalized broadcast transaction object returned by the blockchain client. If returnOrderId was used, the dict includes an "orderid" field.
 
-            Since buy orders are placed as
-            limit-sell orders for the base asset,
-            you may end up obtaining more of the
-            buy asset than you placed the order
-            for. Example:
+        Raises:
+            ValueError: If no account can be resolved.
+            AssertionError: If an Amount is provided whose asset symbol does not match the market quote.
 
-                * You place and order to buy 10 SBD for 100 STEEM/SBD
-                * This means that you actually place a sell order for 1000 STEEM in order to obtain **at least** 10 SBD
-                * If an order on the market exists that sells SBD for cheaper, you will end up with more than 10 SBD
+        Notes:
+            - Because buy orders are implemented as limit-sell orders of the base asset, the trade can result in receiving more of the quote asset than requested if matching orders exist at better prices.
         """
         if not expiration:
             expiration = self.blockchain.config["order-expiration"]
@@ -660,27 +587,26 @@ class Market(dict):
         orderid=None,
         returnOrderId=False,
     ):
-        """Places a sell order in a given market
-
-        :param float price: price denoted in ``base``/``quote``
-        :param number amount: Amount of ``quote`` to sell
-        :param number expiration: (optional) expiration time of the order in seconds (defaults to 7 days)
-        :param bool killfill: flag that indicates if the order shall be killed if it is not filled (defaults to False)
-        :param string account: Account name that executes that order
-        :param string returnOrderId: If set to "head" or "irreversible" the call will wait for the tx to appear in
-            the head/irreversible block and add the key "orderid" to the tx output
+        """
+        Place a limit sell order on this market, selling the market's quote asset for its base asset.
 
-        Prices/Rates are denoted in 'base', i.e. the SBD_STEEM market
-        is priced in STEEM per SBD.
+        This creates a Limit_order_create operation where `amount_to_sell` is the provided `amount` in the market's quote asset and `min_to_receive` is `amount * price` in the market's base asset.
 
-        **Example:** in the SBD_STEEM market, a price of 300 means
-        a SBD is worth 300 STEEM
+        Parameters:
+            price (float or Price): Price expressed as base per quote (e.g., in HBD_HIVE market, a price of 3 means 1 HBD = 3 HIVE).
+            amount (number or str or Amount): Quantity of the quote asset to sell; may be an Amount instance, a string (e.g., "10.000 HBD"), or a numeric value.
+            expiration (int, optional): Order lifetime in seconds; defaults to the node/configured order-expiration (typically 7 days).
+            killfill (bool, optional): If True, treat the order as fill-or-kill (cancel if not fully filled). Defaults to False.
+            account (str, optional): Account name placing the order. If omitted, the configured default_account is used. Raises ValueError if no account is available.
+            orderid (int, optional): Client-provided order identifier; a random 32-bit id is used if not supplied.
+            returnOrderId (bool or str, optional): If truthy (or set to "head"/"irreversible"), the call will wait according to the blocking mode and the returned transaction will include an "orderid" field.
 
-        .. note::
+        Returns:
+            dict: The finalized transaction object returned by the blockchain finalizeOp call. If `returnOrderId` is used, the dict will include an "orderid" key.
 
-            All prices returned are in the **reversed** orientation as the
-            market. I.e. in the STEEM/SBD market, prices are SBD per STEEM.
-            That way you can multiply prices with `1.05` to get a +5%.
+        Raises:
+            ValueError: If no account is provided or available from configuration.
+            AssertionError: If an Amount is provided whose asset symbol does not match the market's quote asset.
         """
         if not expiration:
             expiration = self.blockchain.config["order-expiration"]
@@ -769,8 +695,20 @@ class Market(dict):
 
     @staticmethod
     def btc_usd_ticker(verbose=False):
-        """Returns the BTC/USD price from bitfinex, gdax, kraken, okcoin and bitstamp. The mean price is
-        weighted by the exchange volume.
+        """
+        Return the market-weighted BTC/USD price aggregated from multiple external sources.
+
+        Queries a set of public endpoints (currently CoinGecko; legacy support for Bitfinex, GDAX, Kraken, OKCoin, Bitstamp is present)
+        and computes a volume-weighted average price (VWAP) across successful responses.
+
+        Parameters:
+            verbose (bool): If True, prints the raw price/volume map collected from each source.
+
+        Returns:
+            float: The VWAP of BTC in USD computed from available sources.
+
+        Raises:
+            RuntimeError: If no valid price data could be obtained from any source after several attempts.
         """
         prices = {}
         responses = []
@@ -845,91 +783,17 @@ class Market(dict):
         )
 
     @staticmethod
-    def steem_btc_ticker():
-        """Returns the STEEM/BTC price from bittrex, binance, huobi and upbit. The mean price is
-        weighted by the exchange volume.
+    def hive_btc_ticker():
         """
-        prices = {}
-        responses = []
-        urls = [
-            # "https://poloniex.com/public?command=returnTicker",
-            # "https://bittrex.com/api/v1.1/public/getmarketsummary?market=BTC-STEEM",
-            # "https://api.binance.com/api/v1/ticker/24hr",
-            # "https://api.huobi.pro/market/history/kline?period=1day&size=1&symbol=steembtc",
-            # "https://crix-api.upbit.com/v1/crix/trades/ticks?code=CRIX.UPBIT.BTC-STEEM&count=1",
-            "https://api.coingecko.com/api/v3/simple/price?ids=steem&vs_currencies=btc&include_24hr_vol=true",
-        ]
-        headers = {
-            "Content-type": "application/x-www-form-urlencoded",
-            "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36",
-        }
-        cnt = 0
-        while len(prices) == 0 and cnt < 5:
-            cnt += 1
-            try:
-                responses = list(requests.get(u, headers=headers, timeout=30) for u in urls)
-            except Exception as e:
-                log.debug(str(e))
-
-            for r in [
-                x
-                for x in responses
-                if hasattr(x, "status_code") and x.status_code == 200 and x.json()
-            ]:
-                try:
-                    if "poloniex" in r.url:
-                        data = r.json()["BTC_STEEM"]
-                        prices["poloniex"] = {
-                            "price": float(data["last"]),
-                            "volume": float(data["baseVolume"]),
-                        }
-                    elif "bittrex" in r.url:
-                        data = r.json()["result"][0]
-                        price = (data["Bid"] + data["Ask"]) / 2
-                        prices["bittrex"] = {"price": price, "volume": data["BaseVolume"]}
-                    elif "binance" in r.url:
-                        data = [x for x in r.json() if x["symbol"] == "STEEMBTC"][0]
-                        prices["binance"] = {
-                            "price": float(data["lastPrice"]),
-                            "volume": float(data["quoteVolume"]),
-                        }
-                    elif "huobi" in r.url:
-                        data = r.json()["data"][-1]
-                        prices["huobi"] = {
-                            "price": float(data["close"]),
-                            "volume": float(data["vol"]),
-                        }
-                    elif "upbit" in r.url:
-                        data = r.json()[-1]
-                        prices["upbit"] = {
-                            "price": float(data["tradePrice"]),
-                            "volume": float(data["tradeVolume"]),
-                        }
-                    elif "coingecko" in r.url:
-                        data = r.json()["steem"]
-                        if "usd_24h_vol" in data:
-                            volume = float(data["usd_24h_vol"])
-                        else:
-                            volume = 1
-                        prices["coingecko"] = {"price": float(data["btc"]), "volume": volume}
-                except KeyError as e:
-                    log.info(str(e))
+        Return the HIVE/BTC price as a volume-weighted average from multiple public exchanges.
 
-        if len(prices) == 0:
-            raise RuntimeError("Obtaining STEEM/BTC prices has failed from all sources.")
+        Queries several public APIs (CoinGecko and others) to collect recent HIVE/BTC prices and 24h volumes, then computes a volume-weighted average price (VWAP). The function retries up to 5 times if no valid responses are obtained.
 
-        return Market._weighted_average(
-            [x["price"] for x in prices.values()], [x["volume"] for x in prices.values()]
-        )
+        Returns:
+            float: VWAP price expressed in BTC per 1 HIVE.
 
-    def steem_usd_implied(self):
-        """Returns the current STEEM/USD market price"""
-        return self.steem_btc_ticker() * self.btc_usd_ticker()
-
-    @staticmethod
-    def hive_btc_ticker():
-        """Returns the HIVE/BTC price from bittrex and upbit. The mean price is
-        weighted by the exchange volume.
+        Raises:
+            RuntimeError: If no valid price data could be obtained from any source.
         """
         prices = {}
         responses = []

nectar/memo.py

@@ -19,7 +19,7 @@ class Memo(object):
 
     :param Account from_account: Account that has sent the memo
     :param Account to_account: Account that has received the memo
-    :param Steem blockchain_instance: Steem instance
+    :param Hive blockchain_instance: Hive instance
 
     A memo is encrypted with a shared secret derived from a private key of
     the sender and a public key of the receiver. Due to the underlying
@@ -51,7 +51,7 @@ class Memo(object):
 
     Memo Keys
 
-    In Steem, memos are AES-256 encrypted with a shared secret between sender and
+    In Hive, memos are AES-256 encrypted with a shared secret between sender and
     receiver. It is derived from the memo private key of the sender and the memo
     public key of the receiver.
 
@@ -136,11 +136,23 @@ class Memo(object):
     """
 
     def __init__(self, from_account=None, to_account=None, blockchain_instance=None, **kwargs):
-        if blockchain_instance is None:
-            if kwargs.get("steem_instance"):
-                blockchain_instance = kwargs["steem_instance"]
-            elif kwargs.get("hive_instance"):
-                blockchain_instance = kwargs["hive_instance"]
+        """
+        Initialize a Memo helper that resolves sender/recipient identifiers into Account/Key objects.
+
+        If `from_account`/`to_account` are provided as strings shorter than 51 characters they are treated as account names and resolved to Account(...) using the selected blockchain instance. Strings with length >= 51 are treated as raw keys and converted to PrivateKey (for `from_account`) or PublicKey (for `to_account`). If an input is omitted, the corresponding attribute is set to None.
+
+        Also sets self.blockchain to the provided blockchain_instance or, if None, the shared blockchain instance.
+
+        Parameters:
+            from_account (str|Account|PrivateKey|None): Sender identity — an account name (resolved to Account) or a private key string (resolved to PrivateKey). If already an Account/PrivateKey object, it will be assigned as-is by calling the appropriate constructor above.
+            to_account (str|Account|PublicKey|None): Recipient identity — an account name (resolved to Account) or a public key string (resolved to PublicKey).
+            blockchain_instance (optional): Blockchain client/instance to use for Account resolution; if omitted the shared blockchain instance is used.
+
+        Attributes set:
+            self.blockchain: blockchain instance used for key/account resolution.
+            self.from_account: Account or PrivateKey instance (or None).
+            self.to_account: Account or PublicKey instance (or None).
+        """
         self.blockchain = blockchain_instance or shared_blockchain_instance()
 
         if to_account and len(to_account) < 51:
@@ -272,20 +284,35 @@ class Memo(object):
         return from_key, to_key, nonce
 
     def decrypt(self, memo):
-        """Decrypt a memo
+        """
+        Decrypt a memo message produced for a transfer.
 
-        :param str memo: encrypted memo message
-        :returns: encrypted memo
-        :rtype: str
+        Accepts either a raw memo string or a transfer-style dict with keys "from", "to", and "memo" or "message". If provided, the memo dict may also contain a "nonce". The function will locate an appropriate private memo key from the local wallet (or use a provided PrivateKey), derive the shared secret with the counterparty public key, and return the decrypted plaintext.
+
+        Parameters:
+            memo (str or dict): Encrypted memo as a string, or a dict in transfer form:
+                {"from": <account|key>, "to": <account|key>, "memo"/"message": <str>, "nonce"?: <int|str>}.
+                - "from"/"to" entries may be account names, account dicts, PublicKey/PrivateKey objects, or omitted.
+
+        Returns:
+            str: Decrypted memo plaintext, or None if `memo` is falsy.
+
+        Raises:
+            MissingKeyError: If no installed private memo key can be found for decrypting the message.
         """
         if not memo:
             return None
         memo_wif = None
         # We first try to decode assuming we received the memo
-        if isinstance(memo, dict) and "to" in memo and "from" in memo and "memo" in memo:
+        if (
+            isinstance(memo, dict)
+            and "to" in memo
+            and "from" in memo
+            and ("memo" in memo or "message" in memo)
+        ):
             memo_to = Account(memo["to"], blockchain_instance=self.blockchain)
             memo_from = Account(memo["from"], blockchain_instance=self.blockchain)
-            message = memo["memo"]
+            message = memo.get("memo") or memo.get("message")
         else:
             memo_to = self.to_account
             memo_from = self.from_account