From d5489ef7bdcd6f345e7ef157b4949f28ade4b7e8 Mon Sep 17 00:00:00 2001
From: micimize <rosenthalm93@gmail.com>
Date: Wed, 2 Aug 2017 14:22:59 -1000
Subject: [PATCH 1/4] fix slightly out of date pa interfaces, update docs a bit

---
 pacli/__main__.py | 7 ++++---
 pacli/keystore.py | 8 +++++---
 requirements.txt  | 3 +--
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/pacli/__main__.py b/pacli/__main__.py
index 8f733ba..2fb162b 100644
--- a/pacli/__main__.py
+++ b/pacli/__main__.py
@@ -335,7 +335,7 @@ def new_deck(provider, deck, broadcast):
     '''
     Spawn a new PeerAssets deck.
 
-    pacli deck -new '{"name": "test", "number_of_decimals": 1, "issue_mode": "ONCE"}'
+    pacli deck --new '{"name": "test", "number_of_decimals": 1, "issue_mode": "ONCE"}'
 
     Will return deck span txid.
     '''
@@ -780,7 +780,8 @@ def cli():
     parser.add_argument("--newaddress", action="store_true",
                         help="generate a new address and import to wallet")
     parser.add_argument("--status", action="store_true", help="show pacli status")
-    parser.add_argument("--addressbalance", action="store", nargs=2, help="check card balance of the address")
+    parser.add_argument("--addressbalance", action="store",
+            metavar=('DECK_ID', 'ADDRESS'), nargs=2, help="check card balance of the address")
 
     deck = subparsers.add_parser('deck', help='Deck manipulation.')
     deck.add_argument("--list", action="store_true", help="list decks")
@@ -827,7 +828,7 @@ def main():
         provider = pa.Holy(network=Settings.network)
 
     provider = KeyedProvider(provider,keysJson=mykeys)
-    set_up(provider)
+    set_up(provider.provider)
 
     args = cli()
 
diff --git a/pacli/keystore.py b/pacli/keystore.py
index 96f260f..2b6efef 100644
--- a/pacli/keystore.py
+++ b/pacli/keystore.py
@@ -55,13 +55,15 @@ def __getattr__(self, name):
     @classmethod
     def importprivkey(self, privkey: str, label: str) -> int:
         """import <privkey> with <label>"""
-        mykey = Kutil(wif=privkey)
+        mykey = Kutil(network=self.provider.network, wif=privkey)
 
         if label not in self.privkeys.keys():
             self.privkeys[label] = []
 
-        if mykey._privkey not in [key['privkey'] for key in self.privkeys[label]]:
-            self.privkeys[label].append({"privkey":mykey._privkey,"address":mykey.address})
+        if mykey.privkey not in [key['privkey'] for key in self.privkeys[label]]:
+            self.privkeys[label].append({
+                "privkey": mykey.privkey,
+                "address": mykey.address })
 
     @classmethod
     def getaddressesbyaccount(self, label: str) -> list:
diff --git a/requirements.txt b/requirements.txt
index f8cf325..65a427c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,3 @@
-pypeerassets>=0.1.1
+pypeerassets>=0.2.1
 terminaltables>=3.1.0
-gnupg>=2.1
 appdirs

From 16c2de990597bf4c6fe9dae16edf58cf652d3222 Mon Sep 17 00:00:00 2001
From: micimize <rosenthalm93@gmail.com>
Date: Thu, 3 Aug 2017 14:04:48 -1000
Subject: [PATCH 2/4] bundled GpgKeystore, use pickle instead of eval

---
 .gitignore        |  3 ++
 pacli/__main__.py | 27 ++++++++---------
 pacli/keystore.py | 77 ++++++++++++++++++++++++++---------------------
 3 files changed, 58 insertions(+), 49 deletions(-)

diff --git a/.gitignore b/.gitignore
index 72364f9..156bd4b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -87,3 +87,6 @@ ENV/
 
 # Rope project settings
 .ropeproject
+
+# vim swap files
+.*.sw*
diff --git a/pacli/__main__.py b/pacli/__main__.py
index 2fb162b..35b527d 100644
--- a/pacli/__main__.py
+++ b/pacli/__main__.py
@@ -10,7 +10,7 @@
 import json
 import logging
 
-from pacli.keystore import read_keystore, write_keystore, KeyedProvider
+from pacli.keystore import GpgKeystore, KeyedProvider
 
 conf_dir = user_config_dir("pacli")
 conf_file = os.path.join(conf_dir, "pacli.conf")
@@ -56,7 +56,7 @@ def set_up(provider):
         if not Settings.production:
             if not provider.listtransactions("PATEST"):
                 pa.pautils.load_p2th_privkeys_into_local_node(provider, prod=False)
-    else:
+    elif Settings.provider != 'holy':
         pa.pautils.load_p2th_privkeys_into_local_node(provider,keyfile)
 
 def default_account_utxo(provider, amount):
@@ -811,24 +811,20 @@ def cli():
 def main():
 
     first_run()
-
-    try:
-        load_conf()
-    except:
-        raise
-
-    mypg = None
-    password = None
-    mykeys = ""
-    mykeys = read_keystore(Settings,keyfile)
+    load_conf()
 
     if Settings.provider.lower() == "rpcnode":
         provider = pa.RpcNode(testnet=Settings.testnet)
     if Settings.provider.lower() == "holy":
         provider = pa.Holy(network=Settings.network)
 
-    provider = KeyedProvider(provider,keysJson=mykeys)
-    set_up(provider.provider)
+    set_up(provider)
+
+    keystore = None
+    if Settings.keystore.lower() == "gnupg":
+        keystore = GpgKeystore(Settings, keyfile)
+    if(keystore):
+        provider = KeyedProvider(provider, keys=keystore.read())
 
     args = cli()
 
@@ -879,7 +875,8 @@ def main():
         if args.info:
             vote_info(provider, args.info)
 
-    write_keystore(Settings,keyfile,provider.dumpprivkeys())
+    if(keystore):
+        keystore.write(provider.dumpprivkeys())
  
 if __name__ == "__main__":
     main()
diff --git a/pacli/keystore.py b/pacli/keystore.py
index 2b6efef..c21620a 100644
--- a/pacli/keystore.py
+++ b/pacli/keystore.py
@@ -1,52 +1,60 @@
-import gnupg
-import getpass
-import sys
+import sys, pickle
+from binascii import hexlify, unhexlify
+import gnupg, getpass
 from pypeerassets.kutil import Kutil
 
-mypg = None
+class GpgKeystore:
+    """
+    Implements reading and writing from gpg encrypted file.
+    python-gnupg is a wrapper around the gpg cli, which makes it inherently fragile
+    Uses pickle because private keys are binary
+    """
+
+    def __init__(self, Settings, keyfile):
+        assert Settings.keystore == "gnupg"
+
+        self._key = Settings.gnupgkey
+        self._keyfile = keyfile
 
-def read_keystore(Settings,keyfile) -> str:
-    mykeys = ""
+        self._init_settings = dict(
+            homedir=Settings.gnupgdir,
+            use_agent=bool(Settings.gnupgagent == "True"),
+            keyring='pubring.gpg',
+            secring='secring.gpg')
+        self.gpg = gnupg.GPG(**self._init_settings)
 
-    if Settings.keystore == "gnupg" and Settings.provider != "rpcnode":
-        mypg = gnupg.GPG(binary='/usr/bin/gpg',homedir=Settings.gnupgdir,use_agent=bool(Settings.gnupgagent=="True"),keyring='pubring.gpg',secring='secring.gpg')
+    def read(self) -> dict:
         password = getpass.getpass("Input gpg key password:")
-        fd = open(keyfile)
-        data = fd.read()
+        contents = open(self._keyfile, 'rb').read()
 
-        if len(data)>0:
-            mykeys = str(mypg.decrypt(data,passphrase=password))
-        fd.close()
-    else:
-        print("using rpcnode")
+        if not len(contents):
+            return {}
 
-    return mykeys
+        decrypted = self.gpg.decrypt(contents, passphrase=password)
 
-def write_keystore(Settings,keyfile,keys):
+        assert decrypted.ok, decrypted.status
+        return pickle.loads(unhexlify(str(decrypted).encode()))
+
+    def write(self, data: dict) -> str:
+        encrypted = self.gpg.encrypt(hexlify(pickle.dumps(data)).decode(), self._key)
+        assert encrypted.ok, encrypted.status
+        keyfile = open(self._keyfile, "w")
+        keyfile.write(str(encrypted))
+        keyfile.close()
 
-    if mypg:
-        data = str(mypg.encrypt(str(keys),Settings.gnupgkey))
-        fd = open(keyfile,"w")
-        fd.write(data)
-        fd.close()
 
 class KeyedProvider:
 
     """
-    Keystore class
+    Wraps a provider, shadowing it's private key management and deferring other logic.
+    Uses an in-memory store to handle
+        importprivkey, getaddressesbyaccount, listaccounts, and dumpprivkeys
     """
 
     @classmethod
-    def __init__(self, provider, keysJson: str=""):
-        """
-        : 
-        """
+    def __init__(self, provider, keys: dict = {}):
         self.provider = provider
-
-        if keysJson != "":
-            self.privkeys = eval(keysJson)
-        else:
-            self.privkeys = {}
+        self.privkeys = keys
 
     @classmethod
     def __getattr__(self, name):
@@ -61,8 +69,7 @@ def importprivkey(self, privkey: str, label: str) -> int:
             self.privkeys[label] = []
 
         if mykey.privkey not in [key['privkey'] for key in self.privkeys[label]]:
-            self.privkeys[label].append({
-                "privkey": mykey.privkey,
+            self.privkeys[label].append({ "privkey": mykey.privkey,
                 "address": mykey.address })
 
     @classmethod
@@ -77,3 +84,5 @@ def listaccounts(self) -> dict:
     @classmethod
     def dumpprivkeys(self) -> dict:
         return self.privkeys
+
+

From 52079f57817ad0b37b755d813666b18f51ff1a2f Mon Sep 17 00:00:00 2001
From: micimize <rosenthalm93@gmail.com>
Date: Sun, 6 Aug 2017 13:31:14 -1000
Subject: [PATCH 3/4] subclass provider dynamically with keystore to pass
 peerassets isinstance checks

---
 pacli/__main__.py | 43 ++++++++++++++++++++++-----------
 pacli/keystore.py | 61 +++++++++++++++++++++++------------------------
 2 files changed, 59 insertions(+), 45 deletions(-)

diff --git a/pacli/__main__.py b/pacli/__main__.py
index 35b527d..6c9409f 100644
--- a/pacli/__main__.py
+++ b/pacli/__main__.py
@@ -10,7 +10,7 @@
 import json
 import logging
 
-from pacli.keystore import GpgKeystore, KeyedProvider
+from pacli.keystore import GpgKeystore, as_local_key_provider
 
 conf_dir = user_config_dir("pacli")
 conf_file = os.path.join(conf_dir, "pacli.conf")
@@ -808,23 +808,37 @@ def cli():
 
     return parser.parse_args()
 
-def main():
 
-    first_run()
-    load_conf()
+def configured_provider(Settings):
+    " resolve settings into configured provider "
 
     if Settings.provider.lower() == "rpcnode":
-        provider = pa.RpcNode(testnet=Settings.testnet)
-    if Settings.provider.lower() == "holy":
-        provider = pa.Holy(network=Settings.network)
+        Provider = pa.RpcNode
+        kwargs = dict(testnet=Settings.testnet)
 
-    set_up(provider)
+    elif Settings.provider.lower() == "holy":
+        Provider = pa.Holy
+        kwargs = dict(network=Settings.network)
+
+    else: raise Exception('invalid provider')
 
-    keystore = None
     if Settings.keystore.lower() == "gnupg":
-        keystore = GpgKeystore(Settings, keyfile)
-    if(keystore):
-        provider = KeyedProvider(provider, keys=keystore.read())
+        Provider = as_local_key_provider(Provider)
+        kwargs['keystore'] = keystore = GpgKeystore(Settings, keyfile)
+
+    print(Provider, kwargs)
+    provider = Provider(**kwargs)
+    set_up(provider)
+
+    return provider
+
+
+def main():
+
+    first_run()
+    load_conf()
+
+    provider = configured_provider(Settings)
 
     args = cli()
 
@@ -875,8 +889,9 @@ def main():
         if args.info:
             vote_info(provider, args.info)
 
-    if(keystore):
-        keystore.write(provider.dumpprivkeys())
+    if (hasattr(provider, 'keystore')):
+        # could possibly make this direct behavior of dumprivkeys
+        provider.keystore.write(provider.dumpprivkeys())
  
 if __name__ == "__main__":
     main()
diff --git a/pacli/keystore.py b/pacli/keystore.py
index c21620a..e2117cc 100644
--- a/pacli/keystore.py
+++ b/pacli/keystore.py
@@ -43,46 +43,45 @@ def write(self, data: dict) -> str:
         keyfile.close()
 
 
-class KeyedProvider:
-
+def as_local_key_provider(Provider):
     """
-    Wraps a provider, shadowing it's private key management and deferring other logic.
-    Uses an in-memory store to handle
-        importprivkey, getaddressesbyaccount, listaccounts, and dumpprivkeys
+    factory for subclassing Providers,
+    allowing for local key management and isinstance checks
     """
 
-    @classmethod
-    def __init__(self, provider, keys: dict = {}):
-        self.provider = provider
-        self.privkeys = keys
+    class LocalKeyProvider(Provider):
+
+        """
+        Wraps a provider, shadowing it's private key management and deferring other logic.
+        Uses an in-memory store to handle
+            importprivkey, getaddressesbyaccount, listaccounts, and dumpprivkeys
+        """
 
-    @classmethod
-    def __getattr__(self, name):
-        return getattr(self.provider, name)
+        def __init__(self, keystore: GpgKeystore, **kwargs):
+            super(Provider, self).__init__(**kwargs)
+            self.keystore = keystore
+            self.privkeys = keystore.read()
 
-    @classmethod
-    def importprivkey(self, privkey: str, label: str) -> int:
-        """import <privkey> with <label>"""
-        mykey = Kutil(network=self.provider.network, wif=privkey)
+        def importprivkey(self, privkey: str, label: str) -> int:
+            """import <privkey> with <label>"""
+            mykey = Kutil(network=self.network, wif=privkey)
 
-        if label not in self.privkeys.keys():
-            self.privkeys[label] = []
+            if label not in self.privkeys.keys():
+                self.privkeys[label] = []
 
-        if mykey.privkey not in [key['privkey'] for key in self.privkeys[label]]:
-            self.privkeys[label].append({ "privkey": mykey.privkey,
-                "address": mykey.address })
+            if mykey.privkey not in [key['privkey'] for key in self.privkeys[label]]:
+                self.privkeys[label].append({ "privkey": mykey.privkey,
+                    "address": mykey.address })
 
-    @classmethod
-    def getaddressesbyaccount(self, label: str) -> list:
-        if label in self.privkeys.keys():
-            return [key["address"] for key in self.privkeys[label]]
+        def getaddressesbyaccount(self, label: str) -> list:
+            if label in self.privkeys.keys():
+                return [key["address"] for key in self.privkeys[label]]
 
-    @classmethod
-    def listaccounts(self) -> dict:
-        return {key:0 for key in self.privkeys.keys()}
+        def listaccounts(self) -> dict:
+            return {key:0 for key in self.privkeys.keys()}
 
-    @classmethod
-    def dumpprivkeys(self) -> dict:
-        return self.privkeys
+        def dumpprivkeys(self) -> dict:
+            return self.privkeys
 
+    return LocalKeyProvider
 

From 5343035d886757bea1d0e3b0e6af931b51aafdab Mon Sep 17 00:00:00 2001
From: micimize <rosenthalm93@gmail.com>
Date: Sun, 6 Aug 2017 14:09:44 -1000
Subject: [PATCH 4/4] make keystore config optional

---
 pacli/__main__.py |  1 -
 pacli/config.py   | 25 ++++++++++++++-----------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/pacli/__main__.py b/pacli/__main__.py
index 6c9409f..43e79a8 100644
--- a/pacli/__main__.py
+++ b/pacli/__main__.py
@@ -826,7 +826,6 @@ def configured_provider(Settings):
         Provider = as_local_key_provider(Provider)
         kwargs['keystore'] = keystore = GpgKeystore(Settings, keyfile)
 
-    print(Provider, kwargs)
     provider = Provider(**kwargs)
     set_up(provider)
 
diff --git a/pacli/config.py b/pacli/config.py
index e1a7365..2dac2fd 100644
--- a/pacli/config.py
+++ b/pacli/config.py
@@ -12,21 +12,24 @@ def write_default_config(conf_file=None):
         with open(conf_file, 'w') as configfile:
             config.write(configfile)
 
+optional = {
+    "keystore": "none",
+    "gnupgdir": "",
+    "gnupgagent": "", 
+    "gnupgkey": ""
+    }
+
+required = { "network", "production", "loglevel", "change"  }
+
 def read_conf(conf_file):
     config = configparser.ConfigParser()
     config.read(conf_file)
     try:
-        settings = {
-            "network": config["settings"]["network"],
-            "production": config["settings"]["production"],
-            "loglevel": config["settings"]["loglevel"],
-            "change": config["settings"]["change"],
-            "provider": config["settings"]["provider"],
-            "keystore": config["settings"]["keystore"],
-            "gnupgdir": config["settings"]["gnupgdir"],
-            "gnupgagent": config["settings"]["gnupgagent"],
-            "gnupgkey": config["settings"]["gnupgkey"]
-            }
+        settings = dict(config["settings"])
+        assert set(settings.keys()).issuperset(required)
+        for k, v in optional.items():
+            settings[k] = settings.get(k, v)
+
     except:
         print("config is outdated, saving current default config to",conf_file+".sample")
         write_default_config(conf_file+".sample")