[memo] simplify the use of bitshares.memo

bitshares/memo.py

@@ -3,7 +3,7 @@ import random
 from bitsharesbase import memo as BtsMemo
 from bitsharesbase.account import PrivateKey, PublicKey
 from .account import Account
-from .exceptions import MissingKeyError
+from .exceptions import MissingKeyError, KeyNotFound
 
 
 class Memo(object):
@@ -23,24 +23,38 @@ class Memo(object):
 
             from bitshares.memo import Memo
             m = Memo("bitshareseu", "wallet.xeroc")
+            m.bitshares.wallet.unlock("secret")
             enc = (m.encrypt("foobar"))
             print(enc)
             >> {'nonce': '17329630356955254641', 'message': '8563e2bb2976e0217806d642901a2855'}
             print(m.decrypt(enc))
             >> foobar
 
+        To decrypt a memo, simply use
+
+        .. code-block:: python
+
+            from bitshares.memo import Memo
+            m = Memo()
+            m.bitshares.wallet.unlock("secret")
+            print(memo.decrypt(op_data["memo"]))
+
+        if ``op_data`` being the payload of a transfer operation.
+
     """
     def __init__(
         self,
-        from_account,
-        to_account,
+        from_account=None,
+        to_account=None,
         bitshares_instance=None
     ):
 
         self.bitshares = bitshares_instance or shared_bitshares_instance()
 
-        self.to_account = Account(to_account, bitshares_instance=self.bitshares)
-        self.from_account = Account(from_account, bitshares_instance=self.bitshares)
+        if to_account:
+            self.to_account = Account(to_account, bitshares_instance=self.bitshares)
+        if from_account:
+            self.from_account = Account(from_account, bitshares_instance=self.bitshares)
 
     def encrypt(self, memo):
         """ Encrypt a memo
@@ -86,19 +100,29 @@ class Memo(object):
         if not memo:
             return None
 
-        memo_wif = self.bitshares.wallet.getPrivateKeyForPublicKey(
-            self.to_account["options"]["memo_key"]
-        )
-        if not memo_wif:
-            raise MissingKeyError("Memo key for %s missing!" % self.to_account["name"])
+        # We first try to decode assuming we received the memo
+        try:
+            memo_wif = self.bitshares.wallet.getPrivateKeyForPublicKey(
+                memo["to"]
+            )
+            pubkey = memo["from"]
+        except KeyNotFound:
+            try:
+                # if that failed, we assume that we have sent the memo
+                memo_wif = self.bitshares.wallet.getPrivateKeyForPublicKey(
+                    memo["from"]
+                )
+                pubkey = memo["to"]
+            except KeyNotFound:
+                # if all fails, raise exception
+                raise MissingKeyError(
+                    "Non of the required memo keys are installed!"
+                    "Need any of {}".format(
+                    [memo["to"], memo["from"]]))
 
-        # TODO: Use pubkeys of the message, not pubkeys of account!
         return BtsMemo.decode_memo(
             PrivateKey(memo_wif),
-            PublicKey(
-                self.from_account["options"]["memo_key"],
-                prefix=self.bitshares.rpc.chain_params["prefix"]
-            ),
+            PublicKey(pubkey, prefix=self.bitshares.prefix),
             memo.get("nonce"),
             memo.get("message")
         )

bitshares/wallet.py

@@ -7,6 +7,7 @@ from .exceptions import (
     KeyNotFound,
     InvalidWifError,
     WalletExists,
+    WalletLocked,
     WrongMasterPasswordException,
     NoWalletException
 )
@@ -127,6 +128,11 @@ class Wallet():
         """
         self.masterpassword = None
 
+    def unlocked(self):
+        """ Is the wallet database unlocked?
+        """
+        return not self.locked()
+
     def locked(self):
         """ Is the wallet database locked?
         """
@@ -226,6 +232,9 @@ class Wallet():
             if not self.created():
                 raise NoWalletException
 
+            if not self.unlocked():
+                raise WalletLocked
+
             encwif = self.keyStorage.getPrivateKeyForPublicKey(pub)
             if not encwif:
                 raise KeyNotFound("No private key for {} found".format(pub))

docs/memo.rst

@@ -50,8 +50,8 @@ of the message.
 Example
 #######
 
-High Level
-~~~~~~~~~~
+Encrypting a memo
+~~~~~~~~~~~~~~~~~
 
 The high level memo class makes use of the pybitshares wallet to obtain keys
 for the corresponding accounts.
@@ -65,34 +65,29 @@ for the corresponding accounts.
         from_account=Account(from_account),
         to_account=Account(to_account)
     )
-    cipher = memoObj.encrypt(memo)
-    plain = memoObj.decrypt(cipher)
+    encrypted_memo = memoObj.encrypt(memo)
 
-
-Low Level
-~~~~~~~~~
+Decoding of a received memo
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. code-block:: python
 
-    from bitsharesbase.memo import memo
-    from bitsharesbase.account import PrivateKey, PublicKey
+     from getpass import getpass
+     from bitshares.block import Block
+     from bitshares.memo import Memo
 
-    wifkey = "5....<wif>"
-    memo         = {
-          "from": "GPH5mgup8evDqMnT86L7scVebRYDC2fwAWmygPEUL43LjstQegYCC",
-          "to": "GPH5Ar4j53kFWuEZQ9XhxbAja4YXMPJ2EnUg5QcrdeMFYUNMMNJbe",
-          "nonce": "13043867485137706821",
-          "message": "d55524c37320920844ca83bb20c8d008"
-        }
-    try :
-        privkey = PrivateKey(wifkey)
-        pubkey  = PublicKey(memo["from"], prefix=prefix)
-        memomsg = memo.decode_memo(privkey, pubkey, memo["nonce"], memo["message"])
-    except Exception as e:
-        memomsg = "--cannot decode-- %s" % str(e)
-
-Definitions
-###########
+     block = Block(23755086)
+     transaction = block["transactions"][3]
+     op = transaction["operations"][0]
+     op_id = op[0]
+     op_data = op[1]
+
+     memo = Memo()
+     memo.bitshares.wallet.unlock(getpass())
+     print(memo.decrypt(op_data["memo"]))
+
+API
+###
 
 .. automodule:: bitsharesbase.memo
     :members: