Merge pull request #304 from kaykurokawa/remove_lbrycrd

Remove lbrycrdd

lbrynet/analytics/events.py

@@ -88,7 +88,6 @@ def make_context(platform, wallet):
             'build': platform['build'],
             'wallet': {
                 'name': wallet,
-                # TODO: add in version info for lbrycrdd
                 'version': platform['lbryum_version'] if wallet == LBRYUM_WALLET else None
             },
         },

lbrynet/conf.py

@@ -130,7 +130,6 @@ ENVIRONMENT = Env(
     upload_log=(bool, True),
     delete_blobs_on_remove=(bool, True),
     use_upnp=(bool, True),
-    start_lbrycrdd=(bool, True),
     run_reflector_server=(bool, False),
     startup_scripts=(list, []),
     # TODO: this doesn't seem like the kind of thing that should

lbrynet/core/Wallet.py

@@ -1,13 +1,8 @@
-import sys
 import datetime
 import logging
 import json
-import subprocess
-import socket
-import time
 import os
 
-from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
 from twisted.internet import threads, reactor, defer, task
 from twisted.python.failure import Failure
 from twisted.enterprise import adbapi
@@ -62,15 +57,6 @@ class ClaimOutpoint(dict):
         return not self.__eq__(compare)
 
 
-def _catch_connection_error(f):
-    def w(*args):
-        try:
-            return f(*args)
-        except socket.error:
-            raise ValueError(
-                "Unable to connect to an lbrycrd server. Make sure an lbrycrd server " +
-                "is running and that this application can connect to it.")
-    return w
 
 
 class Wallet(object):
@@ -774,356 +760,6 @@ class Wallet(object):
         pass
 
 
-class LBRYcrdWallet(Wallet):
-    def __init__(self, db_dir, wallet_dir=None, wallet_conf=None, lbrycrdd_path=None):
-        Wallet.__init__(self, db_dir)
-        self.started_lbrycrdd = False
-        self.wallet_dir = wallet_dir
-        self.wallet_conf = wallet_conf
-        self.lbrycrdd = None
-        self.lbrycrdd_path = lbrycrdd_path
-
-        settings = self._get_rpc_conf()
-        rpc_user = settings["username"]
-        rpc_pass = settings["password"]
-        rpc_port = settings["rpc_port"]
-        rpc_url = "127.0.0.1"
-        self.rpc_conn_string = "http://%s:%s@%s:%s" % (rpc_user, rpc_pass, rpc_url, str(rpc_port))
-
-    def _start(self):
-        return threads.deferToThread(self._make_connection)
-
-    def _stop(self):
-        if self.lbrycrdd_path is not None:
-            return self._stop_daemon()
-
-    def _make_connection(self):
-        alert.info("Connecting to lbrycrdd...")
-        if self.lbrycrdd_path is not None:
-            self._start_daemon()
-        self._get_info_rpc()
-        log.info("Connected!")
-        alert.info("Connected to lbrycrdd.")
-
-    def _get_rpc_conf(self):
-        settings = {"username": "rpcuser",
-                    "password": "rpcpassword",
-                    "rpc_port": 9245}
-        if self.wallet_conf and os.path.exists(self.wallet_conf):
-            conf = open(self.wallet_conf)
-            for l in conf:
-                if l.startswith("rpcuser="):
-                    settings["username"] = l[8:].rstrip('\n')
-                if l.startswith("rpcpassword="):
-                    settings["password"] = l[12:].rstrip('\n')
-                if l.startswith("rpcport="):
-                    settings["rpc_port"] = int(l[8:].rstrip('\n'))
-        return settings
-
-    def _check_first_run(self):
-        d = self.get_balance()
-        d.addCallback(lambda bal: threads.deferToThread(self._get_num_addresses_rpc) if bal == 0 else 2)
-        d.addCallback(lambda num_addresses: True if num_addresses <= 1 else False)
-        return d
-
-    def get_new_address(self):
-        return threads.deferToThread(self._get_new_address_rpc)
-
-    def get_balance(self):
-        return threads.deferToThread(self._get_wallet_balance_rpc)
-
-    def get_most_recent_blocktime(self):
-        d = threads.deferToThread(self._get_best_blockhash_rpc)
-        d.addCallback(lambda blockhash: threads.deferToThread(self._get_block_rpc, blockhash))
-        d.addCallback(
-            lambda block: block['time'] if 'time' in block else Failure(ValueError("Could not get a block time")))
-        return d
-
-    def get_name_claims(self):
-        return threads.deferToThread(self._get_name_claims_rpc)
-
-    def get_block(self, blockhash):
-        return threads.deferToThread(self._get_block_rpc, blockhash)
-
-    def get_best_blockhash(self):
-        d = threads.deferToThread(self._get_blockchain_info_rpc)
-        d.addCallback(lambda blockchain_info: blockchain_info['bestblockhash'])
-        return d
-
-    def get_nametrie(self):
-        return threads.deferToThread(self._get_nametrie_rpc)
-
-    def start_miner(self):
-        d = threads.deferToThread(self._get_gen_status_rpc)
-        d.addCallback(lambda status: threads.deferToThread(self._set_gen_status_rpc, True) if not status
-                      else "Miner was already running")
-        return d
-
-    def stop_miner(self):
-        d = threads.deferToThread(self._get_gen_status_rpc)
-        d.addCallback(lambda status: threads.deferToThread(self._set_gen_status_rpc, False) if status
-                      else "Miner wasn't running")
-        return d
-
-    def get_miner_status(self):
-        return threads.deferToThread(self._get_gen_status_rpc)
-
-    def _get_balance_for_address(self, address):
-        return threads.deferToThread(self._get_balance_for_address_rpc, address)
-
-    def _do_send_many(self, payments_to_send):
-        outputs = {address: float(points) for address, points in payments_to_send.iteritems()}
-        return threads.deferToThread(self._do_send_many_rpc, outputs)
-
-    def _send_name_claim(self, name, value, amount):
-        return threads.deferToThread(self._send_name_claim_rpc, name, value, amount)
-
-    def _get_raw_tx(self, txid):
-        return threads.deferToThread(self._get_raw_tx_rpc, txid)
-
-    def _get_decoded_tx(self, raw_tx):
-        return threads.deferToThread(self._get_decoded_tx_rpc, raw_tx)
-
-    def _get_transaction(self, txid):
-        return threads.deferToThread(self._get_raw_tx_rpc, txid, 1)
-
-    def _send_abandon(self, txid, address, amount):
-        return threads.deferToThread(self._send_abandon_rpc, txid, address, amount)
-
-    def _send_name_claim_update(self, name, claim_id, claim_outpoint, value, amount):
-        return threads.deferToThread(self._update_name_rpc, claim_outpoint, value, amount)
-
-    def _support_claim(self, name, claim_id, amount):
-        return threads.deferToThread(self._support_claim_rpc, name, claim_id, amount)
-
-    def _get_claims_for_name(self, name):
-        return threads.deferToThread(self._get_claims_for_name_rpc, name)
-
-    def get_claims_from_tx(self, txid):
-        return threads.deferToThread(self._get_claims_from_tx_rpc, txid)
-
-    def _get_blockhash(self, blockhash):
-        return threads.deferToThread(self._get_blockhash_rpc, blockhash)
-
-    def _get_value_for_name(self, name):
-        return threads.deferToThread(self._get_value_for_name_rpc, name)
-
-    def _get_history(self):
-        return threads.deferToThread(self._list_transactions_rpc)
-
-    def _address_is_mine(self, address):
-        return threads.deferToThread(self._get_address_is_mine_rpc, address)
-
-    def _get_rpc_conn(self):
-        return AuthServiceProxy(self.rpc_conn_string)
-
-    def _start_daemon(self):
-
-        tries = 0
-        try:
-            rpc_conn = self._get_rpc_conn()
-            try:
-                rpc_conn.getinfo()
-            except ValueError:
-                log.exception('Failed to get rpc info. Rethrowing with a hopefully more useful error message')
-                raise Exception('Failed to get rpc info from lbrycrdd.  Try restarting lbrycrdd') 
-            log.info("lbrycrdd was already running when LBRYcrdWallet was started.")
-            return
-        except (socket.error, JSONRPCException):
-            tries += 1
-            log.info("lbrcyrdd was not running when LBRYcrdWallet was started. Attempting to start it.")
-
-        try:
-            if os.name == "nt":
-                si = subprocess.STARTUPINFO
-                si.dwFlags = subprocess.STARTF_USESHOWWINDOW
-                si.wShowWindow = subprocess.SW_HIDE
-                self.lbrycrdd = subprocess.Popen([self.lbrycrdd_path, "-datadir=%s" % self.wallet_dir,
-                                                  "-conf=%s" % self.wallet_conf], startupinfo=si)
-            else:
-                if sys.platform == 'darwin':
-                    os.chdir("/Applications/LBRY.app/Contents/Resources")
-                self.lbrycrdd = subprocess.Popen([self.lbrycrdd_path, "-datadir=%s" % self.wallet_dir,
-                                                  "-conf=%s" % self.wallet_conf])
-            self.started_lbrycrdd = True
-        except OSError:
-            import traceback
-            log.error("Couldn't launch lbrycrdd at path %s: %s", self.lbrycrdd_path, traceback.format_exc())
-            raise ValueError("Couldn't launch lbrycrdd. Tried %s" % self.lbrycrdd_path)
-
-        while tries < 6:
-            try:
-                rpc_conn = self._get_rpc_conn()
-                rpc_conn.getinfo()
-                break
-            except (socket.error, JSONRPCException):
-                tries += 1
-                log.warning("Failed to connect to lbrycrdd.")
-                if tries < 6:
-                    time.sleep(2 ** tries)
-                    log.warning("Trying again in %d seconds", 2 ** tries)
-                else:
-                    log.warning("Giving up.")
-        else:
-            self.lbrycrdd.terminate()
-            raise ValueError("Couldn't open lbrycrdd")
-
-    def _stop_daemon(self):
-        if self.lbrycrdd is not None and self.started_lbrycrdd is True:
-            alert.info("Stopping lbrycrdd...")
-            d = threads.deferToThread(self._stop_rpc)
-            d.addCallback(lambda _: alert.info("Stopped lbrycrdd."))
-            return d
-        return defer.succeed(True)
-
-    @_catch_connection_error
-    def _get_balance_for_address_rpc(self, address):
-        rpc_conn = self._get_rpc_conn()
-        balance = rpc_conn.getreceivedbyaddress(address)
-        log.debug("received balance for %s: %s", str(address), str(balance))
-        return balance
-
-    @_catch_connection_error
-    def _do_send_many_rpc(self, payments):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.sendmany("", payments)
-
-    @_catch_connection_error
-    def _get_info_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getinfo()
-
-    @_catch_connection_error
-    def _get_name_claims_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.listnameclaims()
-
-    @_catch_connection_error
-    def _get_gen_status_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getgenerate()
-
-    @_catch_connection_error
-    def _set_gen_status_rpc(self, b):
-        if b:
-            log.info("Starting miner")
-        else:
-            log.info("Stopping miner")
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.setgenerate(b)
-
-    @_catch_connection_error
-    def _get_raw_tx_rpc(self, txid, raw=0):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getrawtransaction(txid, raw)
-
-    @_catch_connection_error
-    def _get_decoded_tx_rpc(self, raw):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.decoderawtransaction(raw)
-
-    @_catch_connection_error
-    def _send_abandon_rpc(self, txid, address, amount):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.abandonclaim(txid, address, amount)
-
-    @_catch_connection_error
-    def _get_blockchain_info_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getblockchaininfo()
-
-    @_catch_connection_error
-    def _get_block_rpc(self, blockhash):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getblock(blockhash)
-
-    @_catch_connection_error
-    def _get_blockhash_rpc(self, height):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getblockhash(height)
-
-    @_catch_connection_error
-    def _get_claims_from_tx_rpc(self, txid):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getclaimsfortx(txid)
-
-    @_catch_connection_error
-    def _get_claims_for_name_rpc(self, name):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getclaimsforname(name)
-
-    @_catch_connection_error
-    def _get_nametrie_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getclaimtrie()
-
-    @_catch_connection_error
-    def _get_wallet_balance_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getbalance("")
-
-    @_catch_connection_error
-    def _get_new_address_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getnewaddress()
-
-    @_catch_connection_error
-    def _get_value_for_name_rpc(self, name):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getvalueforname(name)
-
-    @_catch_connection_error
-    def _update_name_rpc(self, claim_outpoint, value, amount):
-        # TODO use nout in updateclaim once lbrycrdd uses it
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.updateclaim(claim_outpoint['txid'], json.dumps(value), amount)
-
-    @_catch_connection_error
-    def _send_name_claim_rpc(self, name, value, amount):
-        rpc_conn = self._get_rpc_conn()
-        try:
-            return str(rpc_conn.claimname(name, json.dumps(value), amount))
-        except JSONRPCException as e:
-            if 'message' in e.error and e.error['message'] == "Insufficient funds":
-                raise InsufficientFundsError()
-            elif 'message' in e.error:
-                raise ValueError(e.error['message'])
-
-    @_catch_connection_error
-    def _support_claim_rpc(self, name, claim_id, amount):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.supportclaim(name, claim_id, amount)
-
-    @_catch_connection_error
-    def _get_num_addresses_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return len(rpc_conn.getaddressesbyaccount(""))
-
-    @_catch_connection_error
-    def _get_best_blockhash_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.getbestblockhash()
-
-    @_catch_connection_error
-    def _list_transactions_rpc(self):
-        rpc_conn = self._get_rpc_conn()
-        return rpc_conn.listtransactions()
-
-    @_catch_connection_error
-    def _get_address_is_mine_rpc(self, address):
-        rpc_conn = self._get_rpc_conn()
-        return address in rpc_conn.getaddressesbyaccount("")
-
-    @_catch_connection_error
-    def _stop_rpc(self):
-        # check if our lbrycrdd is actually running, or if we connected to one that was already
-        # running and ours failed to start
-        if self.lbrycrdd.poll() is None:
-            rpc_conn = self._get_rpc_conn()
-            rpc_conn.stop()
-            self.lbrycrdd.wait()
-
-
 class LBRYumWallet(Wallet):
 
     def __init__(self, db_dir, config=None):

lbrynet/lbrynet_daemon/Daemon.py

@@ -44,7 +44,7 @@ from lbrynet.core import log_support, utils, Platform
 from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier, download_sd_blob, BlobStreamDescriptorReader
 from lbrynet.core.Session import Session
 from lbrynet.core.PTCWallet import PTCWallet
-from lbrynet.core.Wallet import LBRYcrdWallet, LBRYumWallet
+from lbrynet.core.Wallet import LBRYumWallet
 from lbrynet.core.looping_call_manager import LoopingCallManager
 from lbrynet.core.server.BlobRequestHandler import BlobRequestHandlerFactory
 from lbrynet.core.server.ServerProtocol import ServerProtocolFactory
@@ -240,7 +240,6 @@ class Daemon(AuthJSONRPCServer):
         self.reflector_port = conf.settings.reflector_port
         self.dht_node_port = conf.settings.dht_node_port
         self.use_upnp = conf.settings.use_upnp
-        self.start_lbrycrdd = conf.settings.start_lbrycrdd
         self.cache_time = conf.settings.cache_time
         self.startup_scripts = conf.settings.startup_scripts
 
@@ -275,7 +274,6 @@ class Daemon(AuthJSONRPCServer):
         self.streams = {}
         self.pending_claims = {}
         self.name_cache = {}
-        self.set_wallet_attributes()
         self.exchange_rate_manager = ExchangeRateManager()
         calls = {
             Checker.INTERNET_CONNECTION: LoopingCall(CheckInternetConnection(self)),
@@ -292,41 +290,6 @@ class Daemon(AuthJSONRPCServer):
         self.lbry_file_metadata_manager = None
         self.lbry_file_manager = None
 
-    @AuthJSONRPCServer.subhandler
-    def _exclude_lbrycrd_only_commands_from_lbryum_session(self, request):
-        request.content.seek(0, 0)
-        content = request.content.read()
-        parsed = jsonrpclib.loads(content)
-        function_path = parsed.get("method")
-        if self.wallet_type == LBRYUM_WALLET and function_path in ['set_miner', 'get_miner_status']:
-            log.warning("Mining commands are not available in lbryum")
-            raise Exception("Command not available in lbryum")
-        return True
-
-    def set_wallet_attributes(self):
-        self.wallet_dir = None
-        if self.wallet_type != LBRYCRD_WALLET:
-            return
-        if os.name == "nt":
-            from lbrynet.winhelpers.knownpaths import get_path, FOLDERID, UserHandle
-            self.lbrycrdd_path = "lbrycrdd.exe"
-            user_app_dir = get_path(FOLDERID.RoamingAppData, UserHandle.current)
-            self.wallet_dir = os.path.join(user_app_dir, "lbrycrd")
-        elif sys.platform == "darwin":
-            self.lbrycrdd_path = get_darwin_lbrycrdd_path()
-            self.wallet_dir = user_data_dir("lbrycrd")
-        else:
-            self.lbrycrdd_path = "lbrycrdd"
-            self.wallet_dir = os.path.join(os.path.expanduser("~"), ".lbrycrd")
-        self.lbrycrd_conf = os.path.join(self.wallet_dir, "lbrycrd.conf")
-        self.wallet_conf = os.path.join(self.wallet_dir, "lbrycrd.conf")
-        if os.name != 'nt':
-            # TODO: are we still using this?
-            lbrycrdd_path_conf = os.path.join(os.path.expanduser("~"), ".lbrycrddpath.conf")
-            if not os.path.isfile(lbrycrdd_path_conf):
-                f = open(lbrycrdd_path_conf, "w")
-                f.write(str(self.lbrycrdd_path))
-                f.close()
 
     def setup(self):
         def _log_starting_vals():
@@ -786,12 +749,7 @@ class Daemon(AuthJSONRPCServer):
 
         def get_wallet():
             if self.wallet_type == LBRYCRD_WALLET:
-                log.info("Using lbrycrd wallet")
+                raise ValueError('LBRYcrd Wallet is no longer supported')
-                wallet = LBRYcrdWallet(self.db_dir,
-                                       wallet_dir=self.wallet_dir,
-                                       wallet_conf=self.lbrycrd_conf,
-                                       lbrycrdd_path=self.lbrycrdd_path)
-                d = defer.succeed(wallet)
             elif self.wallet_type == LBRYUM_WALLET:
                 log.info("Using lbryum wallet")
                 config = {'auto_connect': True}
@@ -1304,7 +1262,6 @@ class Daemon(AuthJSONRPCServer):
             'peer_port': int,
             'dht_node_port': int,
             'use_upnp': bool,
-            'start_lbrycrdd': bool,
         """
 
         log.info("Get daemon settings")
@@ -2402,24 +2359,6 @@ def get_output_callback(params):
     return callback
 
 
-def get_darwin_lbrycrdd_path():
-    # use the path from the bundle if its available.
-    default = "./lbrycrdd"
-    try:
-        import Foundation
-        # TODO: require pyobjc and pyobjc-core on os x
-    except ImportError:
-        log.warning('Foundation module not installed, falling back to default lbrycrdd path')
-        return default
-    else:
-        try:
-            bundle = Foundation.NSBundle.mainBundle()
-            return bundle.pathForResource_ofType_('lbrycrdd', None)
-        except Exception:
-            log.exception('Failed to get path from bundle, falling back to default')
-            return default
-
-
 class _DownloadNameHelper(object):
     def __init__(self, daemon, name, timeout=conf.settings.download_timeout, download_directory=None,
                  file_name=None, wait_for_write=True):

lbrynet/lbrynet_daemon/DaemonControl.py

@@ -45,7 +45,7 @@ def stop():
 def start():
     parser = argparse.ArgumentParser(description="Launch lbrynet-daemon")
     parser.add_argument("--wallet",
-                        help="lbrycrd or lbryum, default lbryum",
+                        help="lbryum or ptc for testing, default lbryum",
                         type=str,
                         default=conf.LBRYUM_WALLET)
     parser.add_argument("--ui", help="path to custom UI folder", default=None)

packaging/osx/lbry-osx-app/lbrygui/LBRYApp.py

@@ -7,19 +7,6 @@ import platform
 import shutil
 from appdirs import user_data_dir
 from twisted.internet import reactor
-import Foundation
-bundle = Foundation.NSBundle.mainBundle()
-lbrycrdd_path = bundle.pathForResource_ofType_('lbrycrdd', None)
-lbrycrdd_path_conf = os.path.join(os.path.expanduser("~"), ".lbrycrddpath.conf")
-wallet_dir = user_data_dir("lbrycrd")
-
-if not os.path.isdir(wallet_dir):
-    shutil.os.mkdir(wallet_dir)
-
-if not os.path.isfile(lbrycrdd_path_conf):
-    f = open(lbrycrdd_path_conf, "w")
-    f.write(lbrycrdd_path)
-    f.close()
 
 from lbrynet.lbrynet_daemon import DaemonControl
 from lbrynet import analytics

packaging/osx/lbry-osx-app/setup_app.sh

@@ -77,16 +77,6 @@ codesign -s "${LBRY_DEVELOPER_ID}" -f "${DEST}/dist/LBRYURIHandler.app/Contents/
 codesign --deep -s "${LBRY_DEVELOPER_ID}" -f "${DEST}/dist/LBRYURIHandler.app/Contents/MacOS/LBRYURIHandler"
 codesign -vvvv "${DEST}/dist/LBRYURIHandler.app"
 
-# add lbrycrdd as a resource. Following
-# http://stackoverflow.com/questions/11370012/can-executables-made-with-py2app-include-other-terminal-scripts-and-run-them
-# LBRYCRDD_URL="$(curl https://api.github.com/repos/lbryio/lbrycrd/releases/latest | grep 'browser_download_url' | grep osx | cut -d'"' -f4)"
-LBRYCRDD_URL="https://github.com/lbryio/lbrycrd/releases/download/v0.3.15/lbrycrd-osx.zip"
-wget "${LBRYCRDD_URL}" --output-document lbrycrd-osx.zip
-unzip -o lbrycrd-osx.zip
-python setup_app.py py2app --resources lbrycrdd
-
-chmod +x "${DEST}/dist/LBRY.app/Contents/Resources/lbrycrdd"
-
 echo "Removing i386 libraries"
 
 remove_arch () {

packaging/ubuntu/lbry

@@ -2,18 +2,6 @@
 
 set -euo pipefail
 
-LBRYCRDDPATHCONF="$HOME/.lbrycrddpath.conf"
-LBRYCRDDIR="$HOME/.lbrycrd"
-LBRYCRDCONF="$LBRYCRDDIR/lbrycrd.conf"
-
-if [ ! -f "$LBRYCRDDPATHCONF" ]; then
-  echo "/usr/bin/lbrycrdd" > "$LBRYCRDDPATHCONF"
-fi
-
-if [ ! -f "$LBRYCRDCONF" ]; then
-  mkdir -p "$LBRYCRDDIR"
-  echo -e "rpcuser=lbryrpc\nrpcpassword=$(env LC_CTYPE=C LC_ALL=C tr -dc A-Za-z0-9 < /dev/urandom | head -c 16 | xargs)" > "$LBRYCRDCONF"
-fi
 
 urlencode() {
   local LANG=C

packaging/ubuntu/ubuntu_package_setup.sh

@@ -178,13 +178,6 @@ for script in "lbry" "lbrynet-daemon" "lbrynet-cli" "stop-lbrynet-daemon"; do
   addlink "/$BINPATH/$script" "usr/bin/$script"
 done
 
-# add lbrycrdd and lbrycrd-cli
-mkdir -p "$PACKAGING_DIR/bins"
-wget "$(curl https://api.github.com/repos/lbryio/lbrycrd/releases/latest | grep 'browser_download_url' | grep linux | cut -d'"' -f4)" --output-document "$PACKAGING_DIR/bins.zip"
-unzip "$PACKAGING_DIR/bins.zip" -d "$PACKAGING_DIR/bins/"
-addfile "$PACKAGING_DIR/bins/lbrycrdd" usr/bin/lbrycrdd
-addfile "$PACKAGING_DIR/bins/lbrycrd-cli" usr/bin/lbrycrd-cli
-
 # add postinstall script
 cat "$PACKAGING_DIR/postinst_append" >> control/postinst
 

requirements.txt

@@ -16,7 +16,6 @@ miniupnpc==1.9
 pbkdf2==1.3
 protobuf==3.0.0
 pycrypto==2.6.1
-python-bitcoinrpc==0.1
 qrcode==5.2.2
 requests==2.9.1
 requests_futures==0.9.7

setup.py

@@ -34,7 +34,6 @@ requires = [
     'miniupnpc',
     'yapsy',
     'seccure',
-    'python-bitcoinrpc==0.1',
     'txJSON-RPC',
     'requests>=2.4.2',
     'unqlite==0.2.0',