diff --git a/.pylintrc b/.pylintrc
index ada0377dd..99ef868eb 100644
--- a/.pylintrc
+++ b/.pylintrc
@@ -9,7 +9,7 @@
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
-ignore=CVS
+ignore=CVS,schema
 
 # Add files or directories matching the regex patterns to the
 # blacklist. The regex matches against base names, not paths.
diff --git a/.travis.yml b/.travis.yml
index a64cbcb35..63422ac60 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,22 +9,19 @@ jobs:
     - stage: code quality
       name: "pylint lbrynet"
       install:
+        - pip install astroid==2.0.4
+        # newer astroid fails in pylint so we pre-install older version
         - pip install pylint
-        - pip install git+https://github.com/lbryio/torba.git
-        - pip install git+https://github.com/lbryio/lbryschema.git
+        - pip install git+https://github.com/lbryio/torba.git#egg=torba
         - pip install -e .
       script: pylint lbrynet
 
     - &tests
       stage: test
-      name: "Unit Tests w/ Python 3.7"
+      name: "Unit Tests"
       install:
         - pip install coverage
-        - pip install git+https://github.com/lbryio/electrumx.git#lbryumx
-        - pip install git+https://github.com/lbryio/orchstr8.git
-        - pip install git+https://github.com/lbryio/lbryschema.git
-        - pip install git+https://github.com/lbryio/lbryumx.git
-        - pip install git+https://github.com/lbryio/torba.git
+        - pip install git+https://github.com/lbryio/torba.git#egg=torba
         - pip install -e .[test]
       script:
         - HOME=/tmp coverage run -p --source=lbrynet -m unittest discover -v tests.unit.wallet
@@ -34,25 +31,12 @@ jobs:
         - bash <(curl -s https://codecov.io/bash)
 
     - <<: *tests
-      name: "Unit Tests w/ Python 3.6"
-      python: "3.6"
-
-    - <<: *tests
-      name: "DHT Tests w/ Python 3.7"
-      script: HOME=/tmp coverage run --source=lbrynet -m twisted.trial --reactor=asyncio tests.functional
-
-    - <<: *tests
-      name: "DHT Tests w/ Python 3.6"
-      python: "3.6"
+      name: "DHT Tests"
       script: HOME=/tmp coverage run --source=lbrynet -m twisted.trial --reactor=asyncio tests.functional
 
     - name: "Integration Tests"
       install:
         - pip install tox-travis coverage
-        - pushd .. && git clone https://github.com/lbryio/electrumx.git --branch lbryumx && popd
-        - pushd .. && git clone https://github.com/lbryio/orchstr8.git && popd
-        - pushd .. && git clone https://github.com/lbryio/lbryschema.git && popd
-        - pushd .. && git clone https://github.com/lbryio/lbryumx.git && cd lbryumx && git checkout afd34f323dd94c516108a65240f7d17aea8efe85 && cd .. && popd
         - pushd .. && git clone https://github.com/lbryio/torba.git && popd
       script: tox
       after_success:
@@ -65,9 +49,9 @@ jobs:
       services:
         - docker
       install:
-        - docker pull cdrx/pyinstaller-windows:python3-32bit
+        - docker pull lbry/pyinstaller34_32bits:py371
       script:
-        - docker run -v "$(pwd):/src/lbry" cdrx/pyinstaller-windows:python3-32bit lbry/scripts/wine_build.sh
+        - docker run -v "$(pwd):/src/lbry" lbry/pyinstaller34_32bits:py371 lbry/scripts/wine_build.sh
         - sudo zip -j dist/lbrynet-windows.zip dist/lbrynet.exe
       addons:
         artifacts:
@@ -79,15 +63,13 @@ jobs:
 
     - &build
       name: "Linux"
-      python: "3.6"
       install:
         - pip3 install pyinstaller
         - pip3 install git+https://github.com/lbryio/torba.git
-        - pip3 install git+https://github.com/lbryio/lbryschema.git
         - python scripts/set_build.py
         - pip3 install -e .
       script:
-        - pyinstaller -F -n lbrynet lbrynet/cli.py
+        - pyinstaller -F -n lbrynet lbrynet/extras/cli.py
         - chmod +x dist/lbrynet
         - zip -j dist/lbrynet-${OS}.zip dist/lbrynet
         - ./dist/lbrynet --version
@@ -104,9 +86,19 @@ jobs:
     - <<: *build
       name: "Mac"
       os: osx
-      osx_image: xcode9.4
+      osx_image: xcode6.4
       language: generic
       env: OS=mac
+      cache: false
+      install:
+        - brew update
+        - brew install python3
+        - pip3 install pyinstaller
+        - git clone https://github.com/lbryio/torba.git --depth 1
+        - sed -i -e "s/'plyvel',//" torba/setup.py
+        - cd torba && pip3 install -e . && cd ..
+        - python scripts/set_build.py
+        - pip3 install -e .
 
 cache:
   directories:
diff --git a/INSTALL.md b/INSTALL.md
index ef4bd9f8c..8a6a9290c 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1,17 +1,17 @@
 # Installing LBRY
 
-If only the json-rpc API server is needed the recommended way to install LBRY is to use a pre-built binary. We provide binaries for all major operating systems. See the [README](README.md).
+If only the JSON-RPC API server is needed, the recommended way to install LBRY is to use a pre-built binary. We provide binaries for all major operating systems. See the [README](README.md).
 
 These instructions are for installing LBRY from source, which is recommended if you are interested in doing development work or LBRY is not available on your operating system (godspeed, TempleOS users).
 
-Here's a video walkthrough of this setup which is itself hosted by the LBRY network and provided via [spee.ch](https://github.com/lbryio/spee.ch):
+Here's a video walkthrough of this setup, which is itself hosted by the LBRY network and provided via [spee.ch](https://github.com/lbryio/spee.ch):
 [![Setup for development](https://spee.ch/2018-10-04-17-13-54-017046806.png)](https://spee.ch/967f99344308f1e90f0620d91b6c93e4dfb240e0/lbrynet-dev-setup.mp4)
 
 ## Prerequisites
 
 Running `lbrynet` from source requires Python 3.6 or higher (3.7 is preferred). Get the installer for your OS [here](https://www.python.org/downloads/release/python-370/)
 
-After installing python 3 you'll need to install some additional libraries depending on your operating system.
+After installing python 3, you'll need to install some additional libraries depending on your operating system.
 
 ### Virtualenv
 
@@ -42,7 +42,7 @@ sudo apt-get install build-essential python3.7 python3.7-dev git python-virtuale
 
 On Raspbian, you will also need to install `python-pyparsing`.
 
-If you're running another Linux flavor, install the equivalent of the above packages for your system.
+If you're running another Linux distro, install the equivalent of the above packages for your system.
 
 ## Installation
 
@@ -51,7 +51,7 @@ To install:
  ```
  git clone https://github.com/lbryio/lbry.git
  cd lbry
- 
+
  virtualenv lbry-venv --python=python3.7
  source lbry-venv/bin/activate
 
@@ -60,7 +60,7 @@ To install:
  pip install --editable .[test]  # [test] installs extras needed for running the tests
  ```
 
-To verify your install, `which lbrynet` should return a path inside of the `lbry-venv` folder created by the `virtualenv` command.
+To verify your installation, `which lbrynet` should return a path inside of the `lbry-venv` folder created by the `virtualenv` command.
 
 ## Run the tests
 To run the unit tests from the repo directory:
diff --git a/README.md b/README.md
index 18326904c..694bd0fb2 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
 # <img src="https://raw.githubusercontent.com/lbryio/lbry/master/lbry.png" alt="LBRY" width="48" height="36" /> LBRY [![Build Status](https://travis-ci.org/lbryio/lbry.svg?branch=master)](https://travis-ci.org/lbryio/lbry) [![Test Coverage](https://codecov.io/gh/lbryio/lbry/branch/master/graph/badge.svg)](https://codecov.io/gh/lbryio/lbry)
 
-LBRY is an open-source protocol providing distribution, discovery, and purchase of digital content (data) via a decentralized network. It utilizes the [LBRY blockchain](https://github.com/lbryio/lbrycrd) as a global namespace and database of digital content. Blockchain entries contain searchable content metadata, identities, and rights and access rules. LBRY also provides a data network that consists of peers uploading and downloading data from other peers, possibly in exchange for payments, and a distributed hash table, used by peers to discover other peers.
+LBRY is an open-source protocol providing distribution, discovery, and purchase of digital content (data) via a decentralized peer-to-peer network. It utilizes the [LBRY blockchain](https://github.com/lbryio/lbrycrd) as a global namespace and database of digital content. Blockchain entries contain searchable content metadata, identities, rights and access rules. LBRY also provides a data network that consists of peers (seeders) uploading and downloading data from other peers, possibly in exchange for payments, as well as a distributed hash table used by peers to discover other peers.
 
-This project provides an SDK for building applications using the LBRY protocol. The SDK is written in Python 3.7+ using Twisted. For other languages or platforms, a JSONRPC API is provided.
+This project provides an SDK for building applications using the LBRY protocol. The SDK is written in Python 3.7+ using Twisted. For other languages or platforms, a JSON-RPC API is provided.
 
 ## Installation
 
-Our [releases page](https://github.com/lbryio/lbry/releases) contains pre-built binaries of the latest release, pre-releases, and past releases, for macOS, Debian-based Linux, and Windows. [Automated travis builds](http://build.lbry.io/daemon/) are also available for testing.
+Our [releases page](https://github.com/lbryio/lbry/releases) contains pre-built binaries of the latest release, pre-releases, and past releases for macOS, Debian-based Linux, and Windows. [Automated travis builds](http://build.lbry.io/daemon/) are also available for testing.
 
 ## Usage
 
@@ -14,13 +14,15 @@ Run `lbrynet start` to launch the API server.
 
 By default, `lbrynet` will provide a JSON-RPC server at `http://localhost:5279`. It is easy to interact with via cURL or sane programming languages.
 
-Our [quickstart guide](http://lbry.io/quickstart) provides a simple walkthrough and examples for learning.
+Our [quickstart guide](https://lbry.tech/playground) provides a simple walkthrough and examples for learning.
+
+With the daemon running, `lbrynet commands` will show you a list of commands.
 
 The full API is documented [here](https://lbry.tech/api/sdk).
 
 ## Running from source
 
-Installing from source is also relatively painless, full instructions are in [INSTALL.md](INSTALL.md)
+Installing from source is also relatively painless. Full instructions are in [INSTALL.md](INSTALL.md)
 
 ## Contributing
 
@@ -41,3 +43,7 @@ The primary contact for this project is [@jackrobison](mailto:jack@lbry.io).
 ## Additional information and links
 
 The documentation for the API can be found [here](https://lbry.tech/api/sdk).
+
+Daemon defaults, ports, and other settings are documented [here](https://lbry.tech/resources/daemon-settings).
+
+Settings can be configured using a daemon-settings.yml file. An example can be found [here](https://github.com/lbryio/lbry/blob/master/example_daemon_settings.yml).
diff --git a/docs/404.html b/docs/404.html
index d7554115d..c6c268ac8 100644
--- a/docs/404.html
+++ b/docs/404.html
@@ -100,7 +100,7 @@
       <div class="md-flex__cell md-flex__cell--shrink">
         <a href="/" title="LBRY" class="md-header-nav__button md-logo">
           
-            <img src="https://s3.amazonaws.com/files.lbry.io/logo-square-white-bookonly.png" width="24" height="24">
+            <img src="https://s3.amazonaws.com/files.lbry.io/logo-square-white-bookonly.png" alt="LBRY logo" width="24" height="24">
           
         </a>
       </div>
@@ -196,7 +196,7 @@
   <label class="md-nav__title md-nav__title--site" for="drawer">
     <span class="md-nav__button md-logo">
       
-        <img src="https://s3.amazonaws.com/files.lbry.io/logo-square-white-bookonly.png" width="48" height="48">
+        <img src="https://s3.amazonaws.com/files.lbry.io/logo-square-white-bookonly.png" alt="LBRY logo" width="48" height="48">
       
     </span>
     LBRY
@@ -304,4 +304,4 @@
       
     
   </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/example_daemon_settings.yml b/example_daemon_settings.yml
new file mode 100644
index 000000000..957a160c2
--- /dev/null
+++ b/example_daemon_settings.yml
@@ -0,0 +1,26 @@
+# This is an example daemon_settings.yml file.
+# See https://lbry.tech/resources/daemon-settings for all configuration keys and values
+
+share_usage_data: True
+
+lbryum_servers:
+  - lbryumx1.lbry.io:50001
+  - lbryumx2.lbry.io:50001
+
+blockchain_name: lbrycrd_main
+
+data_dir: /home/lbry/.lbrynet
+download_directory: /home/lbry/downloads
+
+delete_blobs_on_remove: True
+dht_node_port: 4444
+peer_port: 3333
+use_upnp: True
+
+use_auth_http: True
+use_https: True
+
+#components_to_skip:
+#  - peer_protocol_server
+#  - hash_announcer
+#  - dht
diff --git a/lbrynet/__init__.py b/lbrynet/__init__.py
index d4afab105..ccabee936 100644
--- a/lbrynet/__init__.py
+++ b/lbrynet/__init__.py
@@ -1,7 +1,10 @@
 import logging
+from lbrynet.custom_logger import install_logger
+
 
 __name__ = "lbrynet"
-__version__ = "0.30.1rc1"
+__version__ = "0.30.1rc5"
 version = tuple(__version__.split('.'))
 
+install_logger()
 logging.getLogger(__name__).addHandler(logging.NullHandler())
diff --git a/lbrynet/cryptstream/CryptBlob.py b/lbrynet/blob/CryptBlob.py
similarity index 97%
rename from lbrynet/cryptstream/CryptBlob.py
rename to lbrynet/blob/CryptBlob.py
index 4a942b28f..7538b11d8 100644
--- a/lbrynet/cryptstream/CryptBlob.py
+++ b/lbrynet/blob/CryptBlob.py
@@ -7,7 +7,7 @@ from cryptography.hazmat.primitives.ciphers import Cipher, modes
 from cryptography.hazmat.primitives.ciphers.algorithms import AES
 from cryptography.hazmat.primitives.padding import PKCS7
 from cryptography.hazmat.backends import default_backend
-from lbrynet.core.BlobInfo import BlobInfo
+from lbrynet.p2p.BlobInfo import BlobInfo
 from lbrynet.blob.blob_file import MAX_BLOB_SIZE
 
 log = logging.getLogger(__name__)
@@ -75,7 +75,7 @@ class StreamBlobDecryptor:
         def finish_decrypt():
             bytes_left = len(self.buff) % (AES.block_size // 8)
             if bytes_left != 0:
-                log.warning(self.buff[-1 * (AES.block_size // 8):].encode('hex'))
+                log.warning(binascii.hexlify(self.buff[-1 * (AES.block_size // 8):]).decode())
                 raise Exception("blob %s has incorrect padding: %i bytes left" %
                                 (self.blob.blob_hash, bytes_left))
             data_to_decrypt, self.buff = self.buff, b''
diff --git a/lbrynet/cryptstream/CryptStreamCreator.py b/lbrynet/blob/CryptStreamCreator.py
similarity index 98%
rename from lbrynet/cryptstream/CryptStreamCreator.py
rename to lbrynet/blob/CryptStreamCreator.py
index f9e2494ec..e69eda6d9 100644
--- a/lbrynet/cryptstream/CryptStreamCreator.py
+++ b/lbrynet/blob/CryptStreamCreator.py
@@ -6,7 +6,7 @@ import logging
 
 from cryptography.hazmat.primitives.ciphers.algorithms import AES
 from twisted.internet import defer
-from lbrynet.cryptstream.CryptBlob import CryptStreamBlobMaker
+from lbrynet.blob.CryptBlob import CryptStreamBlobMaker
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/file_manager/EncryptedFileCreator.py b/lbrynet/blob/EncryptedFileCreator.py
similarity index 95%
rename from lbrynet/file_manager/EncryptedFileCreator.py
rename to lbrynet/blob/EncryptedFileCreator.py
index 4e4ec4c37..d8ee1868d 100644
--- a/lbrynet/file_manager/EncryptedFileCreator.py
+++ b/lbrynet/blob/EncryptedFileCreator.py
@@ -2,16 +2,16 @@
 Utilities for turning plain files into LBRY Files.
 """
 
-import logging
 import os
+import logging
 from binascii import hexlify
 
 from twisted.internet import defer
 from twisted.protocols.basic import FileSender
 
-from lbrynet.core.StreamDescriptor import BlobStreamDescriptorWriter, EncryptedFileStreamType
-from lbrynet.core.StreamDescriptor import format_sd_info, get_stream_hash, validate_descriptor
-from lbrynet.cryptstream.CryptStreamCreator import CryptStreamCreator
+from lbrynet.p2p.StreamDescriptor import BlobStreamDescriptorWriter, EncryptedFileStreamType
+from lbrynet.p2p.StreamDescriptor import format_sd_info, get_stream_hash, validate_descriptor
+from lbrynet.blob.CryptStreamCreator import CryptStreamCreator
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/file_manager/EncryptedFileDownloader.py b/lbrynet/blob/EncryptedFileDownloader.py
similarity index 93%
rename from lbrynet/file_manager/EncryptedFileDownloader.py
rename to lbrynet/blob/EncryptedFileDownloader.py
index 3aa38c38b..108bb2f80 100644
--- a/lbrynet/file_manager/EncryptedFileDownloader.py
+++ b/lbrynet/blob/EncryptedFileDownloader.py
@@ -6,13 +6,13 @@ from binascii import hexlify, unhexlify
 
 from twisted.internet import defer
 from lbrynet import conf
-from lbrynet.core.client.StreamProgressManager import FullStreamProgressManager
-from lbrynet.core.HTTPBlobDownloader import HTTPBlobDownloader
-from lbrynet.core.utils import short_hash
-from lbrynet.lbry_file.client.EncryptedFileDownloader import EncryptedFileSaver
-from lbrynet.lbry_file.client.EncryptedFileDownloader import EncryptedFileDownloader
-from lbrynet.file_manager.EncryptedFileStatusReport import EncryptedFileStatusReport
-from lbrynet.core.StreamDescriptor import save_sd_info
+from lbrynet.p2p.client.StreamProgressManager import FullStreamProgressManager
+from lbrynet.p2p.HTTPBlobDownloader import HTTPBlobDownloader
+from lbrynet.utils import short_hash
+from lbrynet.blob.client.EncryptedFileDownloader import EncryptedFileSaver
+from lbrynet.blob.client.EncryptedFileDownloader import EncryptedFileDownloader
+from lbrynet.blob.EncryptedFileStatusReport import EncryptedFileStatusReport
+from lbrynet.p2p.StreamDescriptor import save_sd_info
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/file_manager/EncryptedFileManager.py b/lbrynet/blob/EncryptedFileManager.py
similarity index 94%
rename from lbrynet/file_manager/EncryptedFileManager.py
rename to lbrynet/blob/EncryptedFileManager.py
index ff48cee81..902ecae88 100644
--- a/lbrynet/file_manager/EncryptedFileManager.py
+++ b/lbrynet/blob/EncryptedFileManager.py
@@ -7,15 +7,14 @@ from binascii import hexlify, unhexlify
 
 from twisted.internet import defer, task, reactor
 from twisted.python.failure import Failure
-from lbrynet.reflector.reupload import reflect_file
-from lbrynet.file_manager.EncryptedFileDownloader import ManagedEncryptedFileDownloader
-from lbrynet.file_manager.EncryptedFileDownloader import ManagedEncryptedFileDownloaderFactory
-from lbrynet.core.StreamDescriptor import EncryptedFileStreamType, get_sd_info
-from lbrynet.cryptstream.client.CryptStreamDownloader import AlreadyStoppedError
-from lbrynet.cryptstream.client.CryptStreamDownloader import CurrentlyStoppingError
-from lbrynet.core.utils import safe_start_looping_call, safe_stop_looping_call
 from lbrynet import conf
-
+from lbrynet.extras.reflector.reupload import reflect_file
+from lbrynet.blob.EncryptedFileDownloader import ManagedEncryptedFileDownloader
+from lbrynet.blob.EncryptedFileDownloader import ManagedEncryptedFileDownloaderFactory
+from lbrynet.p2p.StreamDescriptor import EncryptedFileStreamType, get_sd_info
+from lbrynet.blob.client.CryptStreamDownloader import AlreadyStoppedError
+from lbrynet.blob.client.CryptStreamDownloader import CurrentlyStoppingError
+from lbrynet.utils import safe_start_looping_call, safe_stop_looping_call
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/file_manager/EncryptedFileStatusReport.py b/lbrynet/blob/EncryptedFileStatusReport.py
similarity index 100%
rename from lbrynet/file_manager/EncryptedFileStatusReport.py
rename to lbrynet/blob/EncryptedFileStatusReport.py
diff --git a/lbrynet/blob/__init__.py b/lbrynet/blob/__init__.py
index 3c5de8fa9..e69de29bb 100644
--- a/lbrynet/blob/__init__.py
+++ b/lbrynet/blob/__init__.py
@@ -1,4 +0,0 @@
-from .blob_file import BlobFile
-from .creator import BlobFileCreator
-from .writer import HashBlobWriter
-from .reader import HashBlobReader
diff --git a/lbrynet/blob/blob_file.py b/lbrynet/blob/blob_file.py
index 4091913b9..728962971 100644
--- a/lbrynet/blob/blob_file.py
+++ b/lbrynet/blob/blob_file.py
@@ -1,10 +1,10 @@
-import logging
 import os
+import logging
 from twisted.internet import defer, threads
 from twisted.web.client import FileBodyProducer
 from twisted.python.failure import Failure
-from lbrynet.core.Error import DownloadCanceledError, InvalidDataError, InvalidBlobHashError
-from lbrynet.core.utils import is_valid_blobhash
+from lbrynet.cryptoutils import get_lbry_hash_obj
+from lbrynet.p2p.Error import DownloadCanceledError, InvalidDataError, InvalidBlobHashError
 from lbrynet.blob.writer import HashBlobWriter
 from lbrynet.blob.reader import HashBlobReader
 
@@ -12,6 +12,24 @@ log = logging.getLogger(__name__)
 
 MAX_BLOB_SIZE = 2 * 2 ** 20
 
+# digest_size is in bytes, and blob hashes are hex encoded
+blobhash_length = get_lbry_hash_obj().digest_size * 2
+
+
+def is_valid_hashcharacter(char):
+    return char in "0123456789abcdef"
+
+
+def is_valid_blobhash(blobhash):
+    """Checks whether the blobhash is the correct length and contains only
+    valid characters (0-9, a-f)
+
+    @param blobhash: string, the blobhash to check
+
+    @return: True/False
+    """
+    return len(blobhash) == blobhash_length and all(is_valid_hashcharacter(l) for l in blobhash)
+
 
 class BlobFile:
     """
diff --git a/lbrynet/cryptstream/client/CryptBlobHandler.py b/lbrynet/blob/client/CryptBlobHandler.py
similarity index 90%
rename from lbrynet/cryptstream/client/CryptBlobHandler.py
rename to lbrynet/blob/client/CryptBlobHandler.py
index 6f7ae2adb..436901dcd 100644
--- a/lbrynet/cryptstream/client/CryptBlobHandler.py
+++ b/lbrynet/blob/client/CryptBlobHandler.py
@@ -1,6 +1,6 @@
 import binascii
 from twisted.internet import defer
-from lbrynet.cryptstream.CryptBlob import StreamBlobDecryptor
+from lbrynet.blob.CryptBlob import StreamBlobDecryptor
 
 
 class CryptBlobHandler:
diff --git a/lbrynet/cryptstream/client/CryptStreamDownloader.py b/lbrynet/blob/client/CryptStreamDownloader.py
similarity index 95%
rename from lbrynet/cryptstream/client/CryptStreamDownloader.py
rename to lbrynet/blob/client/CryptStreamDownloader.py
index 382365ce4..ae14b0e6d 100644
--- a/lbrynet/cryptstream/client/CryptStreamDownloader.py
+++ b/lbrynet/blob/client/CryptStreamDownloader.py
@@ -1,13 +1,14 @@
-from binascii import unhexlify
 import logging
-from lbrynet.core.client.BlobRequester import BlobRequester
-from lbrynet.core.client.ConnectionManager import ConnectionManager
-from lbrynet.core.client.DownloadManager import DownloadManager
-from lbrynet.core.client.StreamProgressManager import FullStreamProgressManager
-from lbrynet.cryptstream.client.CryptBlobHandler import CryptBlobHandler
+from binascii import unhexlify
 from twisted.internet import defer
 from twisted.python.failure import Failure
 
+from lbrynet.p2p.client.BlobRequester import BlobRequester
+from lbrynet.p2p.client.ConnectionManager import ConnectionManager
+from lbrynet.p2p.client.DownloadManager import DownloadManager
+from lbrynet.p2p.client.StreamProgressManager import FullStreamProgressManager
+from lbrynet.blob.client.CryptBlobHandler import CryptBlobHandler
+
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/lbry_file/client/EncryptedFileDownloader.py b/lbrynet/blob/client/EncryptedFileDownloader.py
similarity index 90%
rename from lbrynet/lbry_file/client/EncryptedFileDownloader.py
rename to lbrynet/blob/client/EncryptedFileDownloader.py
index 7869768ed..059382868 100644
--- a/lbrynet/lbry_file/client/EncryptedFileDownloader.py
+++ b/lbrynet/blob/client/EncryptedFileDownloader.py
@@ -2,14 +2,14 @@ import os
 import logging
 import traceback
 from binascii import hexlify, unhexlify
-
-from lbrynet.core.StreamDescriptor import save_sd_info
-from lbrynet.cryptstream.client.CryptStreamDownloader import CryptStreamDownloader
-from lbrynet.core.client.StreamProgressManager import FullStreamProgressManager
-from lbrynet.core.Error import FileOpenError
-from lbrynet.lbry_file.client.EncryptedFileMetadataHandler import EncryptedFileMetadataHandler
 from twisted.internet import defer, threads
 
+from lbrynet.p2p.StreamDescriptor import save_sd_info
+from lbrynet.blob.client.CryptStreamDownloader import CryptStreamDownloader
+from lbrynet.p2p.client.StreamProgressManager import FullStreamProgressManager
+from lbrynet.p2p.Error import FileOpenError
+from lbrynet.blob.client.EncryptedFileMetadataHandler import EncryptedFileMetadataHandler
+
 
 log = logging.getLogger(__name__)
 
@@ -44,8 +44,19 @@ class EncryptedFileDownloader(CryptStreamDownloader):
                                          self.blob_manager, download_manager)
 
     def _start(self):
+        def check_start_succeeded(success):
+            if success:
+                self.starting = False
+                self.stopped = False
+                self.completed = False
+                return True
+            else:
+                return self._start_failed()
+
+        self.download_manager = self._get_download_manager()
         d = self._setup_output()
-        d.addCallback(lambda _: CryptStreamDownloader._start(self))
+        d.addCallback(lambda _: self.download_manager.start_downloading())
+        d.addCallbacks(check_start_succeeded)
         return d
 
     def _setup_output(self):
diff --git a/lbrynet/lbry_file/client/EncryptedFileMetadataHandler.py b/lbrynet/blob/client/EncryptedFileMetadataHandler.py
similarity index 100%
rename from lbrynet/lbry_file/client/EncryptedFileMetadataHandler.py
rename to lbrynet/blob/client/EncryptedFileMetadataHandler.py
diff --git a/lbrynet/lbry_file/client/EncryptedFileOptions.py b/lbrynet/blob/client/EncryptedFileOptions.py
similarity index 88%
rename from lbrynet/lbry_file/client/EncryptedFileOptions.py
rename to lbrynet/blob/client/EncryptedFileOptions.py
index fbc0d93b6..ca4421d35 100644
--- a/lbrynet/lbry_file/client/EncryptedFileOptions.py
+++ b/lbrynet/blob/client/EncryptedFileOptions.py
@@ -1,6 +1,6 @@
-from lbrynet.core.StreamDescriptor import EncryptedFileStreamType
-from lbrynet.core.StreamDescriptor import EncryptedFileStreamDescriptorValidator
-from lbrynet.core.DownloadOption import DownloadOption, DownloadOptionChoice
+from lbrynet.p2p.StreamDescriptor import EncryptedFileStreamType
+from lbrynet.p2p.StreamDescriptor import EncryptedFileStreamDescriptorValidator
+from lbrynet.p2p.DownloadOption import DownloadOption, DownloadOptionChoice
 
 
 def add_lbry_file_to_sd_identifier(sd_identifier):
diff --git a/lbrynet/core/client/__init__.py b/lbrynet/blob/client/__init__.py
similarity index 100%
rename from lbrynet/core/client/__init__.py
rename to lbrynet/blob/client/__init__.py
diff --git a/lbrynet/blob/creator.py b/lbrynet/blob/creator.py
index d4edbfaeb..af9dc213f 100644
--- a/lbrynet/blob/creator.py
+++ b/lbrynet/blob/creator.py
@@ -3,7 +3,7 @@ import logging
 from io import BytesIO
 from twisted.internet import defer
 from twisted.web.client import FileBodyProducer
-from lbrynet.core.cryptoutils import get_lbry_hash_obj
+from lbrynet.cryptoutils import get_lbry_hash_obj
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/blob/writer.py b/lbrynet/blob/writer.py
index 464e4701c..c66e3b037 100644
--- a/lbrynet/blob/writer.py
+++ b/lbrynet/blob/writer.py
@@ -1,8 +1,8 @@
 import logging
 from io import BytesIO
 from twisted.python.failure import Failure
-from lbrynet.core.Error import DownloadCanceledError, InvalidDataError
-from lbrynet.core.cryptoutils import get_lbry_hash_obj
+from lbrynet.p2p.Error import DownloadCanceledError, InvalidDataError
+from lbrynet.cryptoutils import get_lbry_hash_obj
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/conf.py b/lbrynet/conf.py
index 55ca055bc..757aced9b 100644
--- a/lbrynet/conf.py
+++ b/lbrynet/conf.py
@@ -7,15 +7,15 @@ import sys
 import yaml
 import envparse
 from appdirs import user_data_dir, user_config_dir
-from lbrynet.core import utils
-from lbrynet.core.Error import InvalidCurrencyError, NoSuchDirectoryError
+from lbrynet import utils
+from lbrynet.p2p.Error import InvalidCurrencyError, NoSuchDirectoryError
 from lbrynet.androidhelpers.paths import (
     android_internal_storage_dir,
     android_app_internal_storage_dir
 )
 
 try:
-    from lbrynet.winhelpers.knownpaths import get_path, FOLDERID, UserHandle
+    from lbrynet.winpaths import get_path, FOLDERID, UserHandle
 except (ImportError, ValueError, NameError):
     # Android platform: NameError: name 'c_wchar' is not defined
     pass
diff --git a/lbrynet/core/system_info.py b/lbrynet/core/system_info.py
deleted file mode 100644
index 6209b78b9..000000000
--- a/lbrynet/core/system_info.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import platform
-import json
-import subprocess
-import os
-
-from six.moves.urllib import request
-from six.moves.urllib.error import URLError
-from lbryschema import __version__ as lbryschema_version
-from lbrynet import build_type, __version__ as lbrynet_version
-from lbrynet.conf import ROOT_DIR
-import logging.handlers
-
-log = logging.getLogger(__name__)
-
-
-def get_lbrynet_version() -> str:
-    if build_type.BUILD == "dev":
-        try:
-            with open(os.devnull, 'w') as devnull:
-                git_dir = ROOT_DIR + '/.git'
-                return subprocess.check_output(
-                    ['git', '--git-dir='+git_dir, 'describe', '--dirty', '--always'],
-                    stderr=devnull
-                ).decode().strip().lstrip('v')
-        except (subprocess.CalledProcessError, OSError):
-            log.debug("failed to get version from git")
-    return lbrynet_version
-
-
-def get_platform(get_ip: bool = True) -> dict:
-    p = {
-        "processor": platform.processor(),
-        "python_version": platform.python_version(),
-        "platform": platform.platform(),
-        "os_release": platform.release(),
-        "os_system": platform.system(),
-        "lbrynet_version": get_lbrynet_version(),
-        "lbryschema_version": lbryschema_version,
-        "build": build_type.BUILD,  # CI server sets this during build step
-    }
-    if p["os_system"] == "Linux":
-        try:
-            import distro
-            p["distro"] = distro.info()
-            p["desktop"] = os.environ.get('XDG_CURRENT_DESKTOP', 'Unknown')
-        except ModuleNotFoundError:
-            pass
-
-    # TODO: remove this from get_platform and add a get_external_ip function using treq
-    if get_ip:
-        try:
-            response = json.loads(request.urlopen("https://api.lbry.io/ip").read())
-            if not response['success']:
-                raise URLError("failed to get external ip")
-            p['ip'] = response['data']['ip']
-        except (URLError, AssertionError):
-            p['ip'] = "Could not determine IP"
-
-    return p
diff --git a/lbrynet/core/cryptoutils.py b/lbrynet/cryptoutils.py
similarity index 100%
rename from lbrynet/core/cryptoutils.py
rename to lbrynet/cryptoutils.py
diff --git a/lbrynet/cryptstream/__init__.py b/lbrynet/cryptstream/__init__.py
deleted file mode 100644
index ff8842a67..000000000
--- a/lbrynet/cryptstream/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-"""
-Classes and functions for dealing with Crypt Streams.
-
-Crypt Streams are encrypted blobs and metadata tying those blobs together. At least some of the
-metadata is generally stored in a Stream Descriptor File, for example containing a public key
-used to bind blobs to the stream and a symmetric key used to encrypt the blobs. The list of blobs
-may or may not be present.
-"""
diff --git a/lbrynet/custom_logger.py b/lbrynet/custom_logger.py
index bd608f1cd..8e3499e42 100644
--- a/lbrynet/custom_logger.py
+++ b/lbrynet/custom_logger.py
@@ -102,5 +102,8 @@ class Logger(logging.Logger):
             self._log(TRACE, msg, args, **kwargs)
 
 
-logging.setLoggerClass(Logger)
-logging.addLevelName(TRACE, 'TRACE')
+def install_logger():
+    current = logging.getLoggerClass()
+    if current is not Logger:
+        logging.setLoggerClass(Logger)
+        logging.addLevelName(TRACE, 'TRACE')
diff --git a/lbrynet/daemon/__init__.py b/lbrynet/daemon/__init__.py
deleted file mode 100644
index 7d3f2be07..000000000
--- a/lbrynet/daemon/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from . import Components  # register Component classes
diff --git a/lbrynet/core/call_later_manager.py b/lbrynet/dht/call_later_manager.py
similarity index 100%
rename from lbrynet/core/call_later_manager.py
rename to lbrynet/dht/call_later_manager.py
diff --git a/lbrynet/dht/datastore.py b/lbrynet/dht/datastore.py
index 2ae0f393d..19fa0f84a 100644
--- a/lbrynet/dht/datastore.py
+++ b/lbrynet/dht/datastore.py
@@ -1,5 +1,5 @@
 from collections import UserDict
-from . import constants
+from lbrynet.dht import constants
 
 
 class DictDataStore(UserDict):
@@ -44,7 +44,7 @@ class DictDataStore(UserDict):
             del self[key]
 
     def hasPeersForBlob(self, key):
-        return True if key in self and len(tuple(self.filter_bad_and_expired_peers(key))) else False
+        return bool(key in self and len(tuple(self.filter_bad_and_expired_peers(key))))
 
     def addPeerToBlob(self, contact, key, compact_address, lastPublished, originallyPublished, originalPublisherID):
         if key in self:
diff --git a/lbrynet/dht/encoding.py b/lbrynet/dht/encoding.py
index f31bd119f..4eb4d0764 100644
--- a/lbrynet/dht/encoding.py
+++ b/lbrynet/dht/encoding.py
@@ -1,4 +1,4 @@
-from .error import DecodeError
+from lbrynet.dht.error import DecodeError
 
 
 def bencode(data):
diff --git a/lbrynet/dht/error.py b/lbrynet/dht/error.py
index f61b7944f..44b5a194d 100644
--- a/lbrynet/dht/error.py
+++ b/lbrynet/dht/error.py
@@ -13,14 +13,12 @@ class DecodeError(Exception):
     Should be raised by an C{Encoding} implementation if decode operation
     fails
     """
-    pass
 
 
 class BucketFull(Exception):
     """
     Raised when the bucket is full
     """
-    pass
 
 
 class UnknownRemoteException(Exception):
diff --git a/lbrynet/dht/interface.py b/lbrynet/dht/interface.py
index e4071dffc..6353dbbfd 100644
--- a/lbrynet/dht/interface.py
+++ b/lbrynet/dht/interface.py
@@ -10,7 +10,6 @@ class IDataStore(Interface):
 
     def keys(self):
         """ Return a list of the keys in this data store """
-        pass
 
     def removeExpiredPeers(self):
         pass
diff --git a/lbrynet/dht/iterativefind.py b/lbrynet/dht/iterativefind.py
index 765c548dc..076bd1a3d 100644
--- a/lbrynet/dht/iterativefind.py
+++ b/lbrynet/dht/iterativefind.py
@@ -1,8 +1,8 @@
 import logging
 from twisted.internet import defer
-from .distance import Distance
-from .error import TimeoutError
-from . import constants
+from lbrynet.dht.distance import Distance
+from lbrynet.dht.error import TimeoutError
+from lbrynet.dht import constants
 
 log = logging.getLogger(__name__)
 
@@ -67,7 +67,7 @@ class _IterativeFind:
 
     def getContactTriples(self, result):
         if self.is_find_value_request:
-            contact_triples = result['contacts']
+            contact_triples = result[b'contacts']
         else:
             contact_triples = result
         for contact_tup in contact_triples:
@@ -112,11 +112,11 @@ class _IterativeFind:
                 # We are looking for a value, and the remote node didn't have it
                 # - mark it as the closest "empty" node, if it is
                 # TODO: store to this peer after finding the value as per the kademlia spec
-                if 'closestNodeNoValue' in self.find_value_result:
+                if b'closestNodeNoValue' in self.find_value_result:
                     if self.is_closer(contact):
-                        self.find_value_result['closestNodeNoValue'] = contact
+                        self.find_value_result[b'closestNodeNoValue'] = contact
                 else:
-                    self.find_value_result['closestNodeNoValue'] = contact
+                    self.find_value_result[b'closestNodeNoValue'] = contact
             contactTriples = self.getContactTriples(result)
             for contactTriple in contactTriples:
                 if (contactTriple[1], contactTriple[2]) in ((c.address, c.port) for c in self.already_contacted):
diff --git a/lbrynet/dht/kbucket.py b/lbrynet/dht/kbucket.py
index 7fffb4ce7..fa3f19d2e 100644
--- a/lbrynet/dht/kbucket.py
+++ b/lbrynet/dht/kbucket.py
@@ -1,8 +1,8 @@
 import logging
 
-from . import constants
-from .distance import Distance
-from .error import BucketFull
+from lbrynet.dht import constants
+from lbrynet.dht.distance import Distance
+from lbrynet.dht.error import BucketFull
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/dht/msgformat.py b/lbrynet/dht/msgformat.py
index fc4381d1c..5e4c59d79 100644
--- a/lbrynet/dht/msgformat.py
+++ b/lbrynet/dht/msgformat.py
@@ -7,7 +7,7 @@
 # The docstrings in this module contain epytext markup; API documentation
 # may be created by processing this file with epydoc: http://epydoc.sf.net
 
-from . import msgtypes
+from lbrynet.dht import msgtypes
 
 
 class MessageTranslator:
diff --git a/lbrynet/dht/msgtypes.py b/lbrynet/dht/msgtypes.py
index 5e19346fc..907c1a8e7 100644
--- a/lbrynet/dht/msgtypes.py
+++ b/lbrynet/dht/msgtypes.py
@@ -7,8 +7,8 @@
 # The docstrings in this module contain epytext markup; API documentation
 # may be created by processing this file with epydoc: http://epydoc.sf.net
 
-from lbrynet.core.utils import generate_id
-from . import constants
+from lbrynet.utils import generate_id
+from lbrynet.dht import constants
 
 
 class Message:
diff --git a/lbrynet/dht/node.py b/lbrynet/dht/node.py
index 7d6c79ea8..8fc590cb5 100644
--- a/lbrynet/dht/node.py
+++ b/lbrynet/dht/node.py
@@ -5,17 +5,12 @@ from functools import reduce
 
 from twisted.internet import defer, error, task
 
-from lbrynet.core.utils import generate_id, DeferredDict
-from lbrynet.core.call_later_manager import CallLaterManager
-from lbrynet.core.PeerManager import PeerManager
-from .error import TimeoutError
-from . import constants
-from . import routingtable
-from . import datastore
-from . import protocol
-from .peerfinder import DHTPeerFinder
-from .contact import ContactManager
-from .iterativefind import iterativeFind
+from lbrynet.utils import generate_id, DeferredDict
+from lbrynet.dht.call_later_manager import CallLaterManager
+from lbrynet.dht.error import TimeoutError
+from lbrynet.dht import constants, routingtable, datastore, protocol
+from lbrynet.dht.contact import ContactManager
+from lbrynet.dht.iterativefind import iterativeFind
 
 log = logging.getLogger(__name__)
 
@@ -83,8 +78,8 @@ class Node(MockKademliaHelper):
     def __init__(self, node_id=None, udpPort=4000, dataStore=None,
                  routingTableClass=None, networkProtocol=None,
                  externalIP=None, peerPort=3333, listenUDP=None,
-                 callLater=None, resolve=None, clock=None, peer_finder=None,
-                 peer_manager=None, interface='', externalUDPPort=None):
+                 callLater=None, resolve=None, clock=None,
+                 interface='', externalUDPPort=None):
         """
         @param dataStore: The data store to use. This must be class inheriting
                           from the C{DataStore} interface (or providing the
@@ -124,20 +119,13 @@ class Node(MockKademliaHelper):
         else:
             self._routingTable = routingTableClass(self.node_id, self.clock.seconds)
 
-        # Initialize this node's network access mechanisms
-        if networkProtocol is None:
-            self._protocol = protocol.KademliaProtocol(self)
-        else:
-            self._protocol = networkProtocol
-        # Initialize the data storage mechanism used by this node
+        self._protocol = networkProtocol or protocol.KademliaProtocol(self)
         self.token_secret = self._generateID()
         self.old_token_secret = None
         self.externalIP = externalIP
         self.peerPort = peerPort
         self.externalUDPPort = externalUDPPort or self.port
         self._dataStore = dataStore or datastore.DictDataStore(self.clock.seconds)
-        self.peer_manager = peer_manager or PeerManager()
-        self.peer_finder = peer_finder or DHTPeerFinder(self, self.peer_manager)
         self._join_deferred = None
 
     #def __del__(self):
@@ -228,10 +216,10 @@ class Node(MockKademliaHelper):
                 # find the closest peers to us
                 closest = yield self._iterativeFind(self.node_id, shortlist if not self.contacts else None)
                 yield _ping_contacts(closest)
-                # # query random hashes in our bucket key ranges to fill or split them
-                # random_ids_in_range = self._routingTable.getRefreshList()
-                # while random_ids_in_range:
-                #     yield self.iterativeFindNode(random_ids_in_range.pop())
+                # query random hashes in our bucket key ranges to fill or split them
+                random_ids_in_range = self._routingTable.getRefreshList()
+                while random_ids_in_range:
+                    yield self.iterativeFindNode(random_ids_in_range.pop())
                 defer.returnValue(None)
 
         @defer.inlineCallbacks
@@ -255,7 +243,7 @@ class Node(MockKademliaHelper):
         yield _iterative_join()
 
     @defer.inlineCallbacks
-    def start(self, known_node_addresses=None):
+    def start(self, known_node_addresses=None, block_on_join=False):
         """ Causes the Node to attempt to join the DHT network by contacting the
         known DHT nodes. This can be called multiple times if the previous attempt
         has failed or if the Node has lost all the contacts.
@@ -270,8 +258,11 @@ class Node(MockKademliaHelper):
         self.start_listening()
         yield self._protocol._listening
         # TODO: Refresh all k-buckets further away than this node's closest neighbour
-        yield self.joinNetwork(known_node_addresses or [])
-        self.start_looping_calls()
+        d = self.joinNetwork(known_node_addresses or [])
+        d.addCallback(lambda _: self.start_looping_calls())
+        d.addCallback(lambda _: log.info("Joined the dht"))
+        if block_on_join:
+            yield d
 
     def start_looping_calls(self):
         self.safe_start_looping_call(self._change_token_lc, constants.tokenSecretChangeInterval)
@@ -580,7 +571,7 @@ class Node(MockKademliaHelper):
         """
         return generate_id()
 
-    # from lbrynet.core.utils import profile_deferred
+    # from lbrynet.p2p.utils import profile_deferred
     # @profile_deferred()
     @defer.inlineCallbacks
     def _iterativeFind(self, key, startupShortlist=None, rpc='findNode', exclude=None):
diff --git a/lbrynet/dht/protocol.py b/lbrynet/dht/protocol.py
index 638d975ef..0a00b01f1 100644
--- a/lbrynet/dht/protocol.py
+++ b/lbrynet/dht/protocol.py
@@ -3,12 +3,8 @@ import errno
 from binascii import hexlify
 
 from twisted.internet import protocol, defer
-from .error import BUILTIN_EXCEPTIONS, UnknownRemoteException, TimeoutError, TransportNotConnected
-
-from . import constants
-from . import encoding
-from . import msgtypes
-from . import msgformat
+from lbrynet.dht import constants, encoding, msgformat, msgtypes
+from lbrynet.dht.error import BUILTIN_EXCEPTIONS, UnknownRemoteException, TimeoutError, TransportNotConnected
 
 log = logging.getLogger(__name__)
 
@@ -118,7 +114,20 @@ class KademliaProtocol(protocol.DatagramProtocol):
             return args
         return args + ({b'protocolVersion': self._protocolVersion},)
 
+    @defer.inlineCallbacks
     def sendRPC(self, contact, method, args):
+        for _ in range(constants.rpcAttempts):
+            try:
+                response = yield self._sendRPC(contact, method, args)
+                return response
+            except TimeoutError:
+                if contact.contact_is_good:
+                    log.debug("RETRY %s ON %s", method, contact)
+                    continue
+                else:
+                    raise
+
+    def _sendRPC(self, contact, method, args):
         """
         Sends an RPC to the specified contact
 
@@ -153,11 +162,12 @@ class KademliaProtocol(protocol.DatagramProtocol):
         df = defer.Deferred()
 
         def _remove_contact(failure):  # remove the contact from the routing table and track the failure
+            contact.update_last_failed()
             try:
-                self._node.removeContact(contact)
+                if not contact.contact_is_good:
+                    self._node.removeContact(contact)
             except (ValueError, IndexError):
                 pass
-            contact.update_last_failed()
             return failure
 
         def _update_contact(result):  # refresh the contact in the routing table
@@ -422,7 +432,7 @@ class KademliaProtocol(protocol.DatagramProtocol):
                 else:
                     result = func()
             except Exception as e:
-                log.exception("error handling request for %s:%i %s", senderContact.address, senderContact.port, method)
+                log.error("error handling request for %s:%i %s", senderContact.address, senderContact.port, method)
                 df.errback(e)
             else:
                 df.callback(result)
diff --git a/lbrynet/dht/routingtable.py b/lbrynet/dht/routingtable.py
index 7417e3970..c99003d33 100644
--- a/lbrynet/dht/routingtable.py
+++ b/lbrynet/dht/routingtable.py
@@ -6,14 +6,12 @@
 # may be created by processing this file with epydoc: http://epydoc.sf.net
 
 import random
-from binascii import unhexlify
-
-from twisted.internet import defer
-from . import constants
-from . import kbucket
-from .error import TimeoutError
-from .distance import Distance
 import logging
+from twisted.internet import defer
+
+from lbrynet.dht import constants, kbucket
+from lbrynet.dht.error import TimeoutError
+from lbrynet.dht.distance import Distance
 
 log = logging.getLogger(__name__)
 
@@ -215,7 +213,7 @@ class TreeRoutingTable:
         now = int(self._getTime())
         for bucket in self._buckets[startIndex:]:
             if force or now - bucket.lastAccessed >= constants.refreshTimeout:
-                searchID = self._randomIDInBucketRange(bucketIndex)
+                searchID = self.midpoint_id_in_bucket_range(bucketIndex)
                 refreshIDs.append(searchID)
             bucketIndex += 1
         return refreshIDs
@@ -263,22 +261,25 @@ class TreeRoutingTable:
                 i += 1
         return i
 
-    def _randomIDInBucketRange(self, bucketIndex):
+    def random_id_in_bucket_range(self, bucketIndex):
         """ Returns a random ID in the specified k-bucket's range
 
         @param bucketIndex: The index of the k-bucket to use
         @type bucketIndex: int
         """
-        idValue = random.randrange(
-            self._buckets[bucketIndex].rangeMin, self._buckets[bucketIndex].rangeMax)
-        randomID = hex(idValue)[2:]
-        if randomID[-1] == 'L':
-            randomID = randomID[:-1]
-        if len(randomID) % 2 != 0:
-            randomID = '0' + randomID
-        randomID = unhexlify(randomID)
-        randomID = ((constants.key_bits // 8) - len(randomID)) * b'\x00' + randomID
-        return randomID
+
+        random_id = int(random.randrange(self._buckets[bucketIndex].rangeMin, self._buckets[bucketIndex].rangeMax))
+        return random_id.to_bytes(constants.key_bits // 8, 'big')
+
+    def midpoint_id_in_bucket_range(self, bucketIndex):
+        """ Returns the middle ID in the specified k-bucket's range
+
+        @param bucketIndex: The index of the k-bucket to use
+        @type bucketIndex: int
+        """
+
+        half = int((self._buckets[bucketIndex].rangeMax - self._buckets[bucketIndex].rangeMin) // 2)
+        return int(self._buckets[bucketIndex].rangeMin + half).to_bytes(constants.key_bits // 8, 'big')
 
     def _splitBucket(self, oldBucketIndex):
         """ Splits the specified k-bucket into two new buckets which together
diff --git a/lbrynet/core/server/__init__.py b/lbrynet/extras/__init__.py
similarity index 100%
rename from lbrynet/core/server/__init__.py
rename to lbrynet/extras/__init__.py
diff --git a/lbrynet/cli.py b/lbrynet/extras/cli.py
similarity index 81%
rename from lbrynet/cli.py
rename to lbrynet/extras/cli.py
index 4a3ebc5ed..1d45ddaee 100644
--- a/lbrynet/cli.py
+++ b/lbrynet/extras/cli.py
@@ -20,26 +20,29 @@ from docopt import docopt
 from textwrap import dedent
 
 from lbrynet import __name__ as lbrynet_name
-from lbrynet.daemon.Daemon import Daemon
-from lbrynet.daemon.DaemonControl import start as daemon_main
-from lbrynet.daemon.DaemonConsole import main as daemon_console
-from lbrynet.daemon.auth.client import LBRYAPIClient
-from lbrynet.core.system_info import get_platform
+from lbrynet.extras.daemon.Daemon import Daemon
+from lbrynet.extras.daemon.DaemonControl import start as daemon_main
+from lbrynet.extras.daemon.DaemonConsole import main as daemon_console
+from lbrynet.extras.daemon.auth.client import LBRYAPIClient
+from lbrynet.extras.system_info import get_platform
 
 
 async def execute_command(method, params, conf_path=None):
     # this check if the daemon is running or not
+    api = None
     try:
         api = await LBRYAPIClient.get_client(conf_path)
         await api.status()
     except (ClientConnectorError, ConnectionError):
-        await api.session.close()
+        if api:
+            await api.session.close()
         print("Could not connect to daemon. Are you sure it's running?")
         return 1
 
     # this actually executes the method
+    resp = await api.call(method, params)
+
     try:
-        resp = await api.call(method, params)
         await api.session.close()
         print(json.dumps(resp["result"], indent=2))
     except KeyError:
@@ -58,11 +61,13 @@ def print_help():
        lbrynet [--conf <config file>] <command> [<args>]
     
     EXAMPLES
-       lbrynet commands                 # list available commands
-       lbrynet status                   # get daemon status
-       lbrynet --conf ~/l1.conf status  # like above but using ~/l1.conf as config file
-       lbrynet resolve_name what        # resolve a name
-       lbrynet help resolve_name        # get help for a command
+        lbrynet start                  # starts the daemon. The daemon needs to be running for commands to work
+        lbrynet help                   # display this message
+        lbrynet help <command_name>    # get help for a command(doesn't need the daemon to be running)
+        lbrynet commands               # list available commands
+        lbrynet status                 # get the running status of the daemon
+        lbrynet --conf ~/l1.conf       # use ~/l1.conf as config file
+        lbrynet resolve what           # resolve a name
     """))
 
 
@@ -135,7 +140,7 @@ def main(argv=None):
 
     elif method in ['version', '--version', '-v']:
         print("{lbrynet_name} {lbrynet_version}".format(
-            lbrynet_name=lbrynet_name, **get_platform(get_ip=False)
+            lbrynet_name=lbrynet_name, **get_platform()
         ))
         return 0
 
diff --git a/lbrynet/daemon/Component.py b/lbrynet/extras/daemon/Component.py
similarity index 96%
rename from lbrynet/daemon/Component.py
rename to lbrynet/extras/daemon/Component.py
index 03f03ddf5..8de53a6ae 100644
--- a/lbrynet/daemon/Component.py
+++ b/lbrynet/extras/daemon/Component.py
@@ -1,7 +1,7 @@
 import logging
 from twisted.internet import defer
 from twisted._threads import AlreadyQuit
-from .ComponentManager import ComponentManager
+from lbrynet.extras.daemon.ComponentManager import ComponentManager
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/daemon/ComponentManager.py b/lbrynet/extras/daemon/ComponentManager.py
similarity index 90%
rename from lbrynet/daemon/ComponentManager.py
rename to lbrynet/extras/daemon/ComponentManager.py
index c35b43a64..9af07fd8d 100644
--- a/lbrynet/daemon/ComponentManager.py
+++ b/lbrynet/extras/daemon/ComponentManager.py
@@ -1,7 +1,8 @@
 import logging
 from twisted.internet import defer
-
-from lbrynet.core.Error import ComponentStartConditionNotMet
+from lbrynet.p2p.Error import ComponentStartConditionNotMet
+from lbrynet.extras.daemon.PeerManager import PeerManager
+from lbrynet.extras.daemon.PeerFinder import DHTPeerFinder
 
 log = logging.getLogger(__name__)
 
@@ -33,13 +34,15 @@ class RequiredCondition(metaclass=RequiredConditionType):
 class ComponentManager:
     default_component_classes = {}
 
-    def __init__(self, reactor=None, analytics_manager=None, skip_components=None, **override_components):
+    def __init__(self, reactor=None, analytics_manager=None, skip_components=None,
+                 peer_manager=None, peer_finder=None, **override_components):
         self.skip_components = skip_components or []
-
         self.reactor = reactor
         self.component_classes = {}
         self.components = set()
         self.analytics_manager = analytics_manager
+        self.peer_manager = peer_manager or PeerManager()
+        self.peer_finder = peer_finder or DHTPeerFinder(self)
 
         for component_name, component_class in self.default_component_classes.items():
             if component_name in override_components:
@@ -60,7 +63,8 @@ class ComponentManager:
         try:
             component = self.get_component(condition.component)
             result = condition.evaluate(component)
-        except Exception as err:
+        except Exception:
+            log.exception('failed to evaluate condition:')
             result = False
         return result, "" if result else condition.message
 
@@ -113,10 +117,10 @@ class ComponentManager:
 
         :return: (defer.Deferred)
         """
-
         for component_name, cb in callbacks.items():
             if component_name not in self.component_classes:
-                raise NameError("unknown component: %s" % component_name)
+                if component_name not in self.skip_components:
+                    raise NameError("unknown component: %s" % component_name)
             if not callable(cb):
                 raise ValueError("%s is not callable" % cb)
 
diff --git a/lbrynet/daemon/Components.py b/lbrynet/extras/daemon/Components.py
similarity index 79%
rename from lbrynet/daemon/Components.py
rename to lbrynet/extras/daemon/Components.py
index f5e16a919..8c3f034d5 100644
--- a/lbrynet/daemon/Components.py
+++ b/lbrynet/extras/daemon/Components.py
@@ -2,35 +2,39 @@ import os
 import asyncio
 import logging
 import treq
+import json
 import math
 import binascii
 from hashlib import sha256
 from types import SimpleNamespace
 from twisted.internet import defer, threads, reactor, error, task
-import lbryschema
+
 from aioupnp import __version__ as aioupnp_version
 from aioupnp.upnp import UPnP
 from aioupnp.fault import UPnPError
-from lbrynet import conf
-from lbrynet.core.utils import DeferredDict
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
-from lbrynet.core.RateLimiter import RateLimiter
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier, EncryptedFileStreamType
-from lbrynet.wallet.manager import LbryWalletManager
-from lbrynet.wallet.network import Network
-from lbrynet.core.server.BlobRequestHandler import BlobRequestHandlerFactory
-from lbrynet.core.server.ServerProtocol import ServerProtocolFactory
-from lbrynet.daemon.Component import Component
-from lbrynet.daemon.ExchangeRateManager import ExchangeRateManager
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.dht import node, hashannouncer
-from lbrynet.file_manager.EncryptedFileManager import EncryptedFileManager
-from lbrynet.lbry_file.client.EncryptedFileDownloader import EncryptedFileSaverFactory
-from lbrynet.lbry_file.client.EncryptedFileOptions import add_lbry_file_to_sd_identifier
-from lbrynet.reflector import ServerFactory as reflector_server_factory
 
-from lbrynet.core.utils import generate_id
+import lbrynet.schema
+from lbrynet import conf
+
+from lbrynet.blob.EncryptedFileManager import EncryptedFileManager
+from lbrynet.blob.client.EncryptedFileDownloader import EncryptedFileSaverFactory
+from lbrynet.blob.client.EncryptedFileOptions import add_lbry_file_to_sd_identifier
+from lbrynet.dht.node import Node
+from lbrynet.extras.daemon.Component import Component
+from lbrynet.extras.daemon.ExchangeRateManager import ExchangeRateManager
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.extras.daemon.HashAnnouncer import DHTHashAnnouncer
+from lbrynet.extras.reflector.server.server import ReflectorServerFactory
+from lbrynet.extras.wallet import LbryWalletManager
+from lbrynet.extras.wallet import Network
+from lbrynet.utils import DeferredDict, generate_id
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
+from lbrynet.p2p.RateLimiter import RateLimiter
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.p2p.StreamDescriptor import StreamDescriptorIdentifier, EncryptedFileStreamType
+from lbrynet.p2p.server.BlobRequestHandler import BlobRequestHandlerFactory
+from lbrynet.p2p.server.ServerProtocol import ServerProtocolFactory
+
 
 log = logging.getLogger(__name__)
 
@@ -42,7 +46,6 @@ HEADERS_COMPONENT = "blockchain_headers"
 WALLET_COMPONENT = "wallet"
 DHT_COMPONENT = "dht"
 HASH_ANNOUNCER_COMPONENT = "hash_announcer"
-STREAM_IDENTIFIER_COMPONENT = "stream_identifier"
 FILE_MANAGER_COMPONENT = "file_manager"
 PEER_PROTOCOL_SERVER_COMPONENT = "peer_protocol_server"
 REFLECTOR_COMPONENT = "reflector"
@@ -94,10 +97,19 @@ class ConfigSettings:
         return conf.settings.node_id
 
     @staticmethod
-    def get_external_ip():
-        from lbrynet.core.system_info import get_platform
-        platform = get_platform(get_ip=True)
-        return platform['ip']
+    @defer.inlineCallbacks
+    def get_external_ip():  # used if upnp is disabled or non-functioning
+        try:
+            buf = []
+            response = yield treq.get("https://api.lbry.io/ip")
+            yield treq.collect(response, buf.append)
+            parsed = json.loads(b"".join(buf).decode())
+            if parsed['success']:
+                return parsed['data']['ip']
+            return
+        except Exception as err:
+            return
+
 
 
 # Shorthand for common ConfigSettings methods
@@ -159,7 +171,7 @@ class DatabaseComponent(Component):
                             'Your database is revision %i, expected %i' %
                             (old_revision, self.get_current_db_revision()))
         if old_revision < self.get_current_db_revision():
-            from lbrynet.database.migrator import dbmigrator
+            from lbrynet.extras.daemon.migrator import dbmigrator
             log.info("Upgrading your databases (revision %i to %i)", old_revision, self.get_current_db_revision())
             yield threads.deferToThread(
                 dbmigrator.migrate_db, GCS('data_dir'), old_revision, self.get_current_db_revision()
@@ -190,7 +202,7 @@ class HeadersComponent(Component):
         self.headers_file = os.path.join(self.headers_dir, 'headers')
         self.old_file = os.path.join(conf.settings['lbryum_wallet_dir'], 'blockchain_headers')
         self._downloading_headers = None
-        self._headers_progress_percent = None
+        self._headers_progress_percent = 0
 
     @property
     def component(self):
@@ -336,7 +348,7 @@ class WalletComponent(Component):
         return self.wallet_manager
 
     def get_status(self):
-        if self.wallet_manager:
+        if self.wallet_manager and self.running:
             local_height = self.wallet_manager.network.get_local_height()
             remote_height = self.wallet_manager.network.get_server_height()
             best_hash = self.wallet_manager.get_best_blockhash()
@@ -353,7 +365,7 @@ class WalletComponent(Component):
         conf.settings.ensure_wallet_dir()
         log.info("Starting torba wallet")
         storage = self.component_manager.get_component(DATABASE_COMPONENT)
-        lbryschema.BLOCKCHAIN_NAME = conf.settings['blockchain_name']
+        lbrynet.schema.BLOCKCHAIN_NAME = conf.settings['blockchain_name']
         self.wallet_manager = yield f2d(LbryWalletManager.from_lbrynet_config(conf.settings, storage))
         self.wallet_manager.old_db = storage
         yield f2d(self.wallet_manager.start())
@@ -366,7 +378,7 @@ class WalletComponent(Component):
 
 class BlobComponent(Component):
     component_name = BLOB_COMPONENT
-    depends_on = [DATABASE_COMPONENT, DHT_COMPONENT]
+    depends_on = [DATABASE_COMPONENT]
 
     def __init__(self, component_manager):
         super().__init__(component_manager)
@@ -378,8 +390,12 @@ class BlobComponent(Component):
 
     def start(self):
         storage = self.component_manager.get_component(DATABASE_COMPONENT)
-        dht_node = self.component_manager.get_component(DHT_COMPONENT)
-        self.blob_manager = DiskBlobManager(CS.get_blobfiles_dir(), storage, dht_node._dataStore)
+        datastore = None
+        if DHT_COMPONENT not in self.component_manager.skip_components:
+            dht_node = self.component_manager.get_component(DHT_COMPONENT)
+            if dht_node:
+                datastore = dht_node._dataStore
+        self.blob_manager = DiskBlobManager(CS.get_blobfiles_dir(), storage, datastore)
         return self.blob_manager.setup()
 
     def stop(self):
@@ -424,20 +440,22 @@ class DHTComponent(Component):
         node_id = CS.get_node_id()
         if node_id is None:
             node_id = generate_id()
+        external_ip = self.upnp_component.external_ip
+        if not external_ip:
+            log.warning("UPnP component failed to get external ip")
+            external_ip = yield CS.get_external_ip()
+            if not external_ip:
+                log.warning("failed to get external ip")
 
-        self.dht_node = node.Node(
+        self.dht_node = Node(
             node_id=node_id,
             udpPort=GCS('dht_node_port'),
             externalUDPPort=self.external_udp_port,
-            externalIP=self.upnp_component.external_ip,
+            externalIP=external_ip,
             peerPort=self.external_peer_port
         )
 
-        self.dht_node.start_listening()
-        yield self.dht_node._protocol._listening
-        d = self.dht_node.joinNetwork(GCS('known_dht_nodes'))
-        d.addCallback(lambda _: self.dht_node.start_looping_calls())
-        d.addCallback(lambda _: log.info("Joined the dht"))
+        yield self.dht_node.start(GCS('known_dht_nodes'), block_on_join=False)
         log.info("Started the dht")
 
     @defer.inlineCallbacks
@@ -461,7 +479,7 @@ class HashAnnouncerComponent(Component):
     def start(self):
         storage = self.component_manager.get_component(DATABASE_COMPONENT)
         dht_node = self.component_manager.get_component(DHT_COMPONENT)
-        self.hash_announcer = hashannouncer.DHTHashAnnouncer(dht_node, storage)
+        self.hash_announcer = DHTHashAnnouncer(dht_node, storage)
         yield self.hash_announcer.start()
 
     @defer.inlineCallbacks
@@ -494,41 +512,6 @@ class RateLimiterComponent(Component):
         return defer.succeed(None)
 
 
-class StreamIdentifierComponent(Component):
-    component_name = STREAM_IDENTIFIER_COMPONENT
-    depends_on = [DHT_COMPONENT, RATE_LIMITER_COMPONENT, BLOB_COMPONENT, DATABASE_COMPONENT, WALLET_COMPONENT]
-
-    def __init__(self, component_manager):
-        super().__init__(component_manager)
-        self.sd_identifier = StreamDescriptorIdentifier()
-
-    @property
-    def component(self):
-        return self.sd_identifier
-
-    @defer.inlineCallbacks
-    def start(self):
-        dht_node = self.component_manager.get_component(DHT_COMPONENT)
-        rate_limiter = self.component_manager.get_component(RATE_LIMITER_COMPONENT)
-        blob_manager = self.component_manager.get_component(BLOB_COMPONENT)
-        storage = self.component_manager.get_component(DATABASE_COMPONENT)
-        wallet = self.component_manager.get_component(WALLET_COMPONENT)
-
-        add_lbry_file_to_sd_identifier(self.sd_identifier)
-        file_saver_factory = EncryptedFileSaverFactory(
-            dht_node.peer_finder,
-            rate_limiter,
-            blob_manager,
-            storage,
-            wallet,
-            GCS('download_directory')
-        )
-        yield self.sd_identifier.add_stream_downloader_factory(EncryptedFileStreamType, file_saver_factory)
-
-    def stop(self):
-        pass
-
-
 class PaymentRateComponent(Component):
     component_name = PAYMENT_RATE_COMPONENT
 
@@ -549,8 +532,8 @@ class PaymentRateComponent(Component):
 
 class FileManagerComponent(Component):
     component_name = FILE_MANAGER_COMPONENT
-    depends_on = [DHT_COMPONENT, RATE_LIMITER_COMPONENT, BLOB_COMPONENT, DATABASE_COMPONENT, WALLET_COMPONENT,
-                  STREAM_IDENTIFIER_COMPONENT, PAYMENT_RATE_COMPONENT]
+    depends_on = [RATE_LIMITER_COMPONENT, BLOB_COMPONENT, DATABASE_COMPONENT, WALLET_COMPONENT,
+                  PAYMENT_RATE_COMPONENT]
 
     def __init__(self, component_manager):
         super().__init__(component_manager)
@@ -569,15 +552,26 @@ class FileManagerComponent(Component):
 
     @defer.inlineCallbacks
     def start(self):
-        dht_node = self.component_manager.get_component(DHT_COMPONENT)
         rate_limiter = self.component_manager.get_component(RATE_LIMITER_COMPONENT)
         blob_manager = self.component_manager.get_component(BLOB_COMPONENT)
         storage = self.component_manager.get_component(DATABASE_COMPONENT)
         wallet = self.component_manager.get_component(WALLET_COMPONENT)
-        sd_identifier = self.component_manager.get_component(STREAM_IDENTIFIER_COMPONENT)
+
+        sd_identifier = StreamDescriptorIdentifier()
+        add_lbry_file_to_sd_identifier(sd_identifier)
+        file_saver_factory = EncryptedFileSaverFactory(
+            self.component_manager.peer_finder,
+            rate_limiter,
+            blob_manager,
+            storage,
+            wallet,
+            GCS('download_directory')
+        )
+        yield sd_identifier.add_stream_downloader_factory(EncryptedFileStreamType, file_saver_factory)
+
         payment_rate_manager = self.component_manager.get_component(PAYMENT_RATE_COMPONENT)
         log.info('Starting the file manager')
-        self.file_manager = EncryptedFileManager(dht_node.peer_finder, rate_limiter, blob_manager, wallet,
+        self.file_manager = EncryptedFileManager(self.component_manager.peer_finder, rate_limiter, blob_manager, wallet,
                                                  payment_rate_manager, storage, sd_identifier)
         yield self.file_manager.setup()
         log.info('Done setting up file manager')
@@ -589,7 +583,7 @@ class FileManagerComponent(Component):
 
 class PeerProtocolServerComponent(Component):
     component_name = PEER_PROTOCOL_SERVER_COMPONENT
-    depends_on = [UPNP_COMPONENT, DHT_COMPONENT, RATE_LIMITER_COMPONENT, BLOB_COMPONENT, WALLET_COMPONENT,
+    depends_on = [UPNP_COMPONENT, RATE_LIMITER_COMPONENT, BLOB_COMPONENT, WALLET_COMPONENT,
                   PAYMENT_RATE_COMPONENT]
 
     def __init__(self, component_manager):
@@ -618,7 +612,7 @@ class PeerProtocolServerComponent(Component):
         }
         server_factory = ServerProtocolFactory(
             self.component_manager.get_component(RATE_LIMITER_COMPONENT), query_handlers,
-            self.component_manager.get_component(DHT_COMPONENT).peer_manager
+            self.component_manager.peer_manager
         )
 
         try:
@@ -642,7 +636,7 @@ class PeerProtocolServerComponent(Component):
 
 class ReflectorComponent(Component):
     component_name = REFLECTOR_COMPONENT
-    depends_on = [DHT_COMPONENT, BLOB_COMPONENT, FILE_MANAGER_COMPONENT]
+    depends_on = [BLOB_COMPONENT, FILE_MANAGER_COMPONENT]
 
     def __init__(self, component_manager):
         super().__init__(component_manager)
@@ -656,10 +650,9 @@ class ReflectorComponent(Component):
     @defer.inlineCallbacks
     def start(self):
         log.info("Starting reflector server")
-        dht_node = self.component_manager.get_component(DHT_COMPONENT)
         blob_manager = self.component_manager.get_component(BLOB_COMPONENT)
         file_manager = self.component_manager.get_component(FILE_MANAGER_COMPONENT)
-        reflector_factory = reflector_server_factory(dht_node.peer_manager, blob_manager, file_manager)
+        reflector_factory = ReflectorServerFactory(self.component_manager.peer_manager, blob_manager, file_manager)
         try:
             self.reflector_server = yield reactor.listenTCP(self.reflector_server_port, reflector_factory)
             log.info('Started reflector on port %s', self.reflector_server_port)
@@ -695,10 +688,12 @@ class UPnPComponent(Component):
 
     @defer.inlineCallbacks
     def _setup_redirects(self):
-        upnp_redirects = yield DeferredDict({
-            "UDP": from_future(self.upnp.get_next_mapping(self._int_dht_node_port, "UDP", "LBRY DHT port")),
-            "TCP": from_future(self.upnp.get_next_mapping(self._int_peer_port, "TCP", "LBRY peer port"))
-        })
+        d = {}
+        if PEER_PROTOCOL_SERVER_COMPONENT not in self.component_manager.skip_components:
+            d["TCP"] = from_future(self.upnp.get_next_mapping(self._int_peer_port, "TCP", "LBRY peer port"))
+        if DHT_COMPONENT not in self.component_manager.skip_components:
+            d["UDP"] = from_future(self.upnp.get_next_mapping(self._int_dht_node_port, "UDP", "LBRY DHT port"))
+        upnp_redirects = yield DeferredDict(d)
         self.upnp_redirects.update(upnp_redirects)
 
     @defer.inlineCallbacks
@@ -710,33 +705,41 @@ class UPnPComponent(Component):
                 log.info("found upnp gateway: %s", self.upnp.gateway.manufacturer_string)
             except Exception as err:
                 log.warning("upnp discovery failed: %s", err)
-                return
+                self.upnp = None
 
         # update the external ip
-        try:
-            external_ip = yield from_future(self.upnp.get_external_ip())
-            if external_ip == "0.0.0.0":
-                log.warning("upnp doesn't know the external ip address (returned 0.0.0.0), using fallback")
-                external_ip = CS.get_external_ip()
-            if self.external_ip and self.external_ip != external_ip:
-                log.info("external ip changed from %s to %s", self.external_ip, external_ip)
-            elif not self.external_ip:
-                log.info("got external ip: %s", external_ip)
-            self.external_ip = external_ip
-        except (asyncio.TimeoutError, UPnPError):
-            pass
-
-        if not self.upnp_redirects:  # setup missing redirects
+        external_ip = None
+        if self.upnp:
             try:
-                upnp_redirects = yield DeferredDict({
-                    "UDP": from_future(self.upnp.get_next_mapping(self._int_dht_node_port, "UDP", "LBRY DHT port")),
-                    "TCP": from_future(self.upnp.get_next_mapping(self._int_peer_port, "TCP", "LBRY peer port"))
-                })
+                external_ip = yield from_future(self.upnp.get_external_ip())
+                if external_ip != "0.0.0.0" and not self.external_ip:
+                    log.info("got external ip from UPnP: %s", external_ip)
+            except (asyncio.TimeoutError, UPnPError):
+                pass
+
+        if external_ip == "0.0.0.0" or not external_ip:
+            log.warning("unable to get external ip from UPnP, checking lbry.io fallback")
+            external_ip = yield CS.get_external_ip()
+        if self.external_ip and self.external_ip != external_ip:
+            log.info("external ip changed from %s to %s", self.external_ip, external_ip)
+        self.external_ip = external_ip
+        assert self.external_ip is not None   # TODO: handle going/starting offline
+
+        if not self.upnp_redirects and self.upnp:  # setup missing redirects
+            try:
+                log.info("add UPnP port mappings")
+                d = {}
+                if PEER_PROTOCOL_SERVER_COMPONENT not in self.component_manager.skip_components:
+                    d["TCP"] = from_future(self.upnp.get_next_mapping(self._int_peer_port, "TCP", "LBRY peer port"))
+                if DHT_COMPONENT not in self.component_manager.skip_components:
+                    d["UDP"] = from_future(self.upnp.get_next_mapping(self._int_dht_node_port, "UDP", "LBRY DHT port"))
+                upnp_redirects = yield DeferredDict(d)
+                log.info("set up redirects: %s", upnp_redirects)
                 self.upnp_redirects.update(upnp_redirects)
             except (asyncio.TimeoutError, UPnPError):
                 self.upnp = None
                 return self._maintain_redirects()
-        else:  # check existing redirects are still active
+        elif self.upnp:  # check existing redirects are still active
             found = set()
             mappings = yield from_future(self.upnp.get_redirects())
             for mapping in mappings:
@@ -744,7 +747,7 @@ class UPnPComponent(Component):
                 if proto in self.upnp_redirects and mapping['NewExternalPort'] == self.upnp_redirects[proto]:
                     if mapping['NewInternalClient'] == self.upnp.lan_address:
                         found.add(proto)
-            if 'UDP' not in found:
+            if 'UDP' not in found and DHT_COMPONENT not in self.component_manager.skip_components:
                 try:
                     udp_port = yield from_future(
                         self.upnp.get_next_mapping(self._int_dht_node_port, "UDP", "LBRY DHT port")
@@ -753,7 +756,7 @@ class UPnPComponent(Component):
                     log.info("refreshed upnp redirect for dht port: %i", udp_port)
                 except (asyncio.TimeoutError, UPnPError):
                     del self.upnp_redirects['UDP']
-            if 'TCP' not in found:
+            if 'TCP' not in found and PEER_PROTOCOL_SERVER_COMPONENT not in self.component_manager.skip_components:
                 try:
                     tcp_port = yield from_future(
                         self.upnp.get_next_mapping(self._int_peer_port, "TCP", "LBRY peer port")
@@ -762,22 +765,28 @@ class UPnPComponent(Component):
                     log.info("refreshed upnp redirect for peer port: %i", tcp_port)
                 except (asyncio.TimeoutError, UPnPError):
                     del self.upnp_redirects['TCP']
-            if 'TCP' in self.upnp_redirects and 'UDP' in self.upnp_redirects:
-                log.debug("upnp redirects are still active")
+            if ('TCP' in self.upnp_redirects
+                and PEER_PROTOCOL_SERVER_COMPONENT not in self.component_manager.skip_components) and (
+                    'UDP' in self.upnp_redirects and DHT_COMPONENT not in self.component_manager.skip_components):
+                if self.upnp_redirects:
+                    log.debug("upnp redirects are still active")
 
     @defer.inlineCallbacks
     def start(self):
+        log.info("detecting external ip")
         if not self.use_upnp:
-            self.external_ip = CS.get_external_ip()
+            self.external_ip = yield CS.get_external_ip()
             return
         success = False
         yield self._maintain_redirects()
         if self.upnp:
-            if not self.upnp_redirects:
+            if not self.upnp_redirects and not all([x in self.component_manager.skip_components for x in
+                                                    (DHT_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT)]):
                 log.error("failed to setup upnp, debugging infomation: %s", self.upnp.zipped_debugging_info)
             else:
                 success = True
-                log.debug("set up upnp port redirects for gateway: %s", self.upnp.gateway.manufacturer_string)
+                if self.upnp_redirects:
+                    log.debug("set up upnp port redirects for gateway: %s", self.upnp.gateway.manufacturer_string)
         else:
             log.error("failed to setup upnp")
         self.component_manager.analytics_manager.send_upnp_setup_success_fail(success, self.get_status())
diff --git a/lbrynet/daemon/Daemon.py b/lbrynet/extras/daemon/Daemon.py
similarity index 96%
rename from lbrynet/daemon/Daemon.py
rename to lbrynet/extras/daemon/Daemon.py
index ddc15251d..4a0f91d17 100644
--- a/lbrynet/daemon/Daemon.py
+++ b/lbrynet/extras/daemon/Daemon.py
@@ -14,41 +14,36 @@ from twisted.internet import defer, reactor
 from twisted.internet.task import LoopingCall
 from twisted.python.failure import Failure
 
-from torba.constants import COIN
-from torba.baseaccount import SingleKey, HierarchicalDeterministic
+from torba.client.baseaccount import SingleKey, HierarchicalDeterministic
 
-from lbryschema.claim import ClaimDict
-from lbryschema.uri import parse_lbry_uri
-from lbryschema.error import URIParseError, DecodeError
-from lbryschema.validator import validate_claim_id
-from lbryschema.address import decode_address
-from lbryschema.decode import smart_decode
-
-# TODO: importing this when internet is disabled raises a socket.gaierror
-from lbrynet.core.system_info import get_lbrynet_version
-from lbrynet import conf
-from lbrynet.reflector import reupload
-from lbrynet.daemon.Components import d2f, f2d
-from lbrynet.daemon.Components import WALLET_COMPONENT, DATABASE_COMPONENT, DHT_COMPONENT, BLOB_COMPONENT
-from lbrynet.daemon.Components import STREAM_IDENTIFIER_COMPONENT, FILE_MANAGER_COMPONENT, RATE_LIMITER_COMPONENT
-from lbrynet.daemon.Components import EXCHANGE_RATE_MANAGER_COMPONENT, PAYMENT_RATE_COMPONENT, UPNP_COMPONENT
-from lbrynet.daemon.ComponentManager import RequiredCondition
-from lbrynet.daemon.Downloader import GetStream
-from lbrynet.daemon.Publisher import Publisher
-from lbrynet.daemon.auth.server import AuthJSONRPCServer
-from lbrynet.core import utils, system_info
-from lbrynet.core.StreamDescriptor import download_sd_blob
-from lbrynet.core.Error import InsufficientFundsError, UnknownNameError
-from lbrynet.core.Error import DownloadDataTimeout, DownloadSDTimeout
-from lbrynet.core.Error import NullFundsError, NegativeFundsError
-from lbrynet.core.Error import ResolveError
+from lbrynet import conf, utils, __version__
 from lbrynet.dht.error import TimeoutError
-from lbrynet.core.Peer import Peer
-from lbrynet.core.SinglePeerDownloader import SinglePeerDownloader
-from lbrynet.core.client.StandaloneBlobDownloader import StandaloneBlobDownloader
-from lbrynet.wallet.account import Account as LBCAccount
-from lbrynet.wallet.manager import LbryWalletManager
-from lbrynet.wallet.dewies import dewies_to_lbc, lbc_to_dewies
+from lbrynet.blob.blob_file import is_valid_blobhash
+from lbrynet.extras import system_info
+from lbrynet.extras.reflector import reupload
+from lbrynet.extras.daemon.Components import d2f, f2d
+from lbrynet.extras.daemon.Components import WALLET_COMPONENT, DATABASE_COMPONENT, DHT_COMPONENT, BLOB_COMPONENT
+from lbrynet.extras.daemon.Components import FILE_MANAGER_COMPONENT, RATE_LIMITER_COMPONENT
+from lbrynet.extras.daemon.Components import EXCHANGE_RATE_MANAGER_COMPONENT, PAYMENT_RATE_COMPONENT, UPNP_COMPONENT
+from lbrynet.extras.daemon.ComponentManager import RequiredCondition
+from lbrynet.extras.daemon.Downloader import GetStream
+from lbrynet.extras.daemon.Publisher import Publisher
+from lbrynet.extras.daemon.auth.server import AuthJSONRPCServer
+from lbrynet.extras.wallet import LbryWalletManager
+from lbrynet.extras.wallet.account import Account as LBCAccount
+from lbrynet.extras.wallet.dewies import dewies_to_lbc, lbc_to_dewies
+from lbrynet.p2p.StreamDescriptor import download_sd_blob
+from lbrynet.p2p.Error import InsufficientFundsError, UnknownNameError, DownloadDataTimeout, DownloadSDTimeout
+from lbrynet.p2p.Error import NullFundsError, NegativeFundsError, ResolveError
+from lbrynet.p2p.Peer import Peer
+from lbrynet.p2p.SinglePeerDownloader import SinglePeerDownloader
+from lbrynet.p2p.client.StandaloneBlobDownloader import StandaloneBlobDownloader
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.schema.uri import parse_lbry_uri
+from lbrynet.schema.error import URIParseError, DecodeError
+from lbrynet.schema.validator import validate_claim_id
+from lbrynet.schema.address import decode_address
+from lbrynet.schema.decode import smart_decode
 
 log = logging.getLogger(__name__)
 requires = AuthJSONRPCServer.requires
@@ -211,7 +206,6 @@ class Daemon(AuthJSONRPCServer):
         DATABASE_COMPONENT: "storage",
         DHT_COMPONENT: "dht_node",
         WALLET_COMPONENT: "wallet_manager",
-        STREAM_IDENTIFIER_COMPONENT: "sd_identifier",
         FILE_MANAGER_COMPONENT: "file_manager",
         EXCHANGE_RATE_MANAGER_COMPONENT: "exchange_rate_manager",
         PAYMENT_RATE_COMPONENT: "payment_rate_manager",
@@ -221,7 +215,7 @@ class Daemon(AuthJSONRPCServer):
     }
 
     def __init__(self, analytics_manager=None, component_manager=None):
-        to_skip = list(conf.settings['components_to_skip'])
+        to_skip = conf.settings['components_to_skip']
         if 'reflector' not in to_skip and not conf.settings['run_reflector_server']:
             to_skip.append('reflector')
         looping_calls = {
@@ -242,7 +236,6 @@ class Daemon(AuthJSONRPCServer):
         self.storage = None
         self.dht_node = None
         self.wallet_manager: LbryWalletManager = None
-        self.sd_identifier = None
         self.file_manager = None
         self.exchange_rate_manager = None
         self.payment_rate_manager = None
@@ -306,7 +299,7 @@ class Daemon(AuthJSONRPCServer):
         rate_manager = rate_manager or self.payment_rate_manager
         timeout = timeout or 30
         downloader = StandaloneBlobDownloader(
-            blob_hash, self.blob_manager, self.dht_node.peer_finder, self.rate_limiter,
+            blob_hash, self.blob_manager, self.component_manager.peer_finder, self.rate_limiter,
             rate_manager, self.wallet_manager, timeout
         )
         return downloader.download()
@@ -373,8 +366,8 @@ class Daemon(AuthJSONRPCServer):
             self.analytics_manager.send_download_started(download_id, name, claim_dict)
             self.analytics_manager.send_new_download_start(download_id, name, claim_dict)
             self.streams[sd_hash] = GetStream(
-                self.sd_identifier, self.wallet_manager, self.exchange_rate_manager, self.blob_manager,
-                self.dht_node.peer_finder, self.rate_limiter, self.payment_rate_manager, self.storage,
+                self.file_manager.sd_identifier, self.wallet_manager, self.exchange_rate_manager, self.blob_manager,
+                self.component_manager.peer_finder, self.rate_limiter, self.payment_rate_manager, self.storage,
                 conf.settings['max_key_fee'], conf.settings['disable_max_key_fee'], conf.settings['data_rate'],
                 timeout
             )
@@ -433,7 +426,7 @@ class Daemon(AuthJSONRPCServer):
         if blob:
             return self.blob_manager.get_blob(blob[0])
         return download_sd_blob(
-            sd_hash.decode(), self.blob_manager, self.dht_node.peer_finder, self.rate_limiter,
+            sd_hash.decode(), self.blob_manager, self.component_manager.peer_finder, self.rate_limiter,
             self.payment_rate_manager, self.wallet_manager, timeout=conf.settings['peer_search_timeout'],
             download_mirrors=conf.settings['download_mirrors']
         )
@@ -451,7 +444,7 @@ class Daemon(AuthJSONRPCServer):
         Get total stream size in bytes from a sd blob
         """
 
-        d = self.sd_identifier.get_metadata_for_sd_blob(sd_blob)
+        d = self.file_manager.sd_identifier.get_metadata_for_sd_blob(sd_blob)
         d.addCallback(lambda metadata: metadata.validator.info_to_show())
         d.addCallback(lambda info: int(dict(info)['stream_size']))
         return d
@@ -469,9 +462,7 @@ class Daemon(AuthJSONRPCServer):
         """
         Calculate estimated LBC cost for a stream given its size in bytes
         """
-
         cost = self._get_est_cost_from_stream_size(size)
-
         resolved = await self.wallet_manager.resolve(uri)
 
         if uri in resolved and 'claim' in resolved[uri]:
@@ -536,7 +527,6 @@ class Daemon(AuthJSONRPCServer):
         sd blob will be downloaded to determine the stream size
 
         """
-
         if size is not None:
             return self.get_est_cost_using_known_size(uri, size)
         return self.get_est_cost_from_uri(uri)
@@ -852,7 +842,7 @@ class Daemon(AuthJSONRPCServer):
             message,
             conf.settings.installation_id,
             platform_name,
-            get_lbrynet_version()
+            __version__
         )
         return self._render_response(True)
 
@@ -1225,7 +1215,7 @@ class Daemon(AuthJSONRPCServer):
         )
 
         if self.ledger.network.is_connected:
-            await self.ledger.update_account(account)
+            await self.ledger.subscribe_account(account)
 
         self.default_wallet.save()
 
@@ -1260,7 +1250,7 @@ class Daemon(AuthJSONRPCServer):
         )
 
         if self.ledger.network.is_connected:
-            await self.ledger.update_account(account)
+            await self.ledger.subscribe_account(account)
 
         self.default_wallet.save()
 
@@ -1449,7 +1439,7 @@ class Daemon(AuthJSONRPCServer):
         return self.get_account_or_error(account_id).get_max_gap()
 
     @requires("wallet")
-    def jsonrpc_account_fund(self, to_account, from_account, amount='0.0',
+    def jsonrpc_account_fund(self, to_account=None, from_account=None, amount='0.0',
                              everything=False, outputs=1, broadcast=False):
         """
         Transfer some amount (or --everything) to an account from another
@@ -1458,8 +1448,8 @@ class Daemon(AuthJSONRPCServer):
         be used together with --everything).
 
         Usage:
-            account_fund (<to_account> | --to_account=<to_account>)
-                (<from_account> | --from_account=<from_account>)
+            account_fund [<to_account> | --to_account=<to_account>]
+                [<from_account> | --from_account=<from_account>]
                 (<amount> | --amount=<amount> | --everything)
                 [<outputs> | --outputs=<outputs>]
                 [--broadcast]
@@ -1476,8 +1466,8 @@ class Daemon(AuthJSONRPCServer):
             (map) transaction performing requested action
 
         """
-        to_account = self.get_account_or_error(to_account, 'to_account')
-        from_account = self.get_account_or_error(from_account, 'from_account')
+        to_account = self.get_account_or_default(to_account, 'to_account')
+        from_account = self.get_account_or_default(from_account, 'from_account')
         amount = self.get_dewies_or_error('amount', amount) if amount else None
         if not isinstance(outputs, int):
             raise ValueError("--outputs must be an integer.")
@@ -1488,6 +1478,35 @@ class Daemon(AuthJSONRPCServer):
             outputs=outputs, broadcast=broadcast
         )
 
+    @requires(WALLET_COMPONENT, conditions=[WALLET_IS_UNLOCKED])
+    async def jsonrpc_account_send(self, amount, addresses, account_id=None, broadcast=False):
+        """
+        Send the same number of credits to multiple addresses.
+
+        Usage:
+            account_send <amount> <addresses>... [--account_id=<account_id>] [--broadcast]
+
+        Options:
+            --account_id=<account_id>  : (str) account to fund the transaction
+            --broadcast                : (bool) actually broadcast the transaction, default: false.
+
+        Returns:
+        """
+
+        amount = self.get_dewies_or_error("amount", amount)
+        if not amount:
+            raise NullFundsError
+        elif amount < 0:
+            raise NegativeFundsError()
+
+        for address in addresses:
+            decode_address(address)
+
+        account = self.get_account_or_default(account_id)
+        result = await account.send_to_addresses(amount, addresses, broadcast)
+        self.analytics_manager.send_credits_sent()
+        return result
+
     @requires(WALLET_COMPONENT)
     def jsonrpc_address_is_mine(self, address, account_id=None):
         """
@@ -1777,8 +1796,8 @@ class Daemon(AuthJSONRPCServer):
             results[resolved_uri] = resolved[resolved_uri]
         return results
 
-    @requires(STREAM_IDENTIFIER_COMPONENT, WALLET_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
-              DHT_COMPONENT, RATE_LIMITER_COMPONENT, PAYMENT_RATE_COMPONENT, DATABASE_COMPONENT,
+    @requires(WALLET_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
+              RATE_LIMITER_COMPONENT, PAYMENT_RATE_COMPONENT, DATABASE_COMPONENT,
               conditions=[WALLET_IS_UNLOCKED])
     async def jsonrpc_get(self, uri, file_name=None, timeout=None):
         """
@@ -1837,7 +1856,8 @@ class Daemon(AuthJSONRPCServer):
             raise ResolveError(
                 "Failed to resolve stream at lbry://{}".format(uri.replace("lbry://", ""))
             )
-
+        if 'error' in resolved:
+            raise ResolveError(f"error resolving stream: {resolved['error']}")
         txid, nout, name = resolved['txid'], resolved['nout'], resolved['name']
         claim_dict = ClaimDict.load_dict(resolved['value'])
         sd_hash = claim_dict.source_hash.decode()
@@ -1963,7 +1983,7 @@ class Daemon(AuthJSONRPCServer):
         response = yield self._render_response(result)
         defer.returnValue(response)
 
-    @requires(STREAM_IDENTIFIER_COMPONENT, WALLET_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
+    @requires(WALLET_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
               DHT_COMPONENT, RATE_LIMITER_COMPONENT, PAYMENT_RATE_COMPONENT, DATABASE_COMPONENT,
               conditions=[WALLET_IS_UNLOCKED])
     def jsonrpc_stream_cost_estimate(self, uri, size=None):
@@ -2207,19 +2227,14 @@ class Daemon(AuthJSONRPCServer):
 
         available = await account.get_balance()
         if amount >= available:
-            # TODO: add check for existing claim balance
-            #balance = yield self.wallet.get_max_usable_balance_for_claim(name)
-            #max_bid_amount = balance - MAX_UPDATE_FEE_ESTIMATE
-            #if balance <= MAX_UPDATE_FEE_ESTIMATE:
-            raise InsufficientFundsError(
-                "Insufficient funds, please deposit additional LBC. Minimum additional LBC needed {}"
-                .format(round((amount - available) / COIN + 0.01, 2))
-            )
-            #       .format(MAX_UPDATE_FEE_ESTIMATE - balance))
-            #elif bid > max_bid_amount:
-            #    raise InsufficientFundsError(
-            #        "Please lower the bid value, the maximum amount you can specify for this claim is {}."
-            #            .format(max_bid_amount))
+            existing_claims = await account.get_claims(claim_name=name)
+            if len(existing_claims) == 1:
+                available += existing_claims[0].get_estimator(self.ledger).effective_amount
+            if amount >= available:
+                raise InsufficientFundsError(
+                    f"Please lower the bid value, the maximum amount "
+                    f"you can specify for this claim is {dewies_to_lbc(available)}."
+                )
 
         metadata = metadata or {}
         if fee is not None:
@@ -2271,7 +2286,7 @@ class Daemon(AuthJSONRPCServer):
             }
         }
 
-        # this will be used to verify the format with lbryschema
+        # this will be used to verify the format with lbrynet.schema
         claim_copy = deepcopy(claim_dict)
         if sources is not None:
             claim_dict['stream']['source'] = sources
@@ -2292,7 +2307,7 @@ class Daemon(AuthJSONRPCServer):
             raise Exception("no source provided to publish")
         try:
             ClaimDict.load_dict(claim_copy)
-            # the metadata to use in the claim can be serialized by lbryschema
+            # the metadata to use in the claim can be serialized by lbrynet.schema
         except DecodeError as err:
             # there was a problem with a metadata field, raise an error here rather than
             # waiting to find out when we go to publish the claim (after having made the stream)
@@ -2321,7 +2336,7 @@ class Daemon(AuthJSONRPCServer):
         )
 
     @requires(WALLET_COMPONENT, conditions=[WALLET_IS_UNLOCKED])
-    async def jsonrpc_claim_abandon(self, claim_id=None, txid=None, nout=None, account_id=None):
+    async def jsonrpc_claim_abandon(self, claim_id=None, txid=None, nout=None, account_id=None, blocking=True):
         """
         Abandon a name and reclaim credits from the claim
 
@@ -2329,12 +2344,14 @@ class Daemon(AuthJSONRPCServer):
             claim_abandon [<claim_id> | --claim_id=<claim_id>]
                           [<txid> | --txid=<txid>] [<nout> | --nout=<nout>]
                           [--account_id=<account_id>]
+                          [--blocking]
 
         Options:
             --claim_id=<claim_id>     : (str) claim_id of the claim to abandon
             --txid=<txid>             : (str) txid of the claim to abandon
             --nout=<nout>             : (int) nout of the claim to abandon
             --account_id=<account_id> : (str) id of the account to use
+            --blocking                : (bool) wait until abandon is in mempool
 
         Returns:
             (dict) Dictionary containing result of the claim
@@ -2354,6 +2371,8 @@ class Daemon(AuthJSONRPCServer):
 
         tx = await self.wallet_manager.abandon_claim(claim_id, txid, nout, account)
         self.analytics_manager.send_claim_action('abandon')
+        if blocking:
+            await self.ledger.wait(tx)
         return {"success": True, "tx": tx}
 
     @requires(WALLET_COMPONENT, conditions=[WALLET_IS_UNLOCKED])
@@ -2813,7 +2832,7 @@ class Daemon(AuthJSONRPCServer):
         Delete a blob
 
         Usage:
-            blob_delete (<blob_hash> | --blob_hash=<blob_hash)
+            blob_delete (<blob_hash> | --blob_hash=<blob_hash>)
 
         Options:
             --blob_hash=<blob_hash>  : (str) blob hash of the blob to delete
@@ -2849,7 +2868,7 @@ class Daemon(AuthJSONRPCServer):
             (list) List of contact dictionaries {'host': <peer ip>, 'port': <peer port>, 'node_id': <peer node id>}
         """
 
-        if not utils.is_valid_blobhash(blob_hash):
+        if not is_valid_blobhash(blob_hash):
             raise Exception("invalid blob hash")
 
         finished_deferred = self.dht_node.iterativeFindValue(unhexlify(blob_hash))
@@ -3125,6 +3144,7 @@ class Daemon(AuthJSONRPCServer):
         result['buckets'] = {}
 
         for i in range(len(self.dht_node._routingTable._buckets)):
+            result['buckets'][i] = []
             for contact in self.dht_node._routingTable._buckets[i]._contacts:
                 blobs = list(hosts.pop(contact)) if contact in hosts else []
                 blob_hashes.update(blobs)
@@ -3134,7 +3154,7 @@ class Daemon(AuthJSONRPCServer):
                     "node_id": hexlify(contact.id).decode(),
                     "blobs": blobs,
                 }
-                result['buckets'].setdefault(i, []).append(host)
+                result['buckets'][i].append(host)
                 contact_set.add(hexlify(contact.id).decode())
 
         result['contacts'] = list(contact_set)
diff --git a/lbrynet/daemon/DaemonConsole.py b/lbrynet/extras/daemon/DaemonConsole.py
similarity index 97%
rename from lbrynet/daemon/DaemonConsole.py
rename to lbrynet/extras/daemon/DaemonConsole.py
index 58355c7fc..d3a1c1d67 100644
--- a/lbrynet/daemon/DaemonConsole.py
+++ b/lbrynet/extras/daemon/DaemonConsole.py
@@ -6,12 +6,10 @@ import logging.handlers
 from twisted.internet import defer, reactor, threads
 from aiohttp import client_exceptions
 
-from lbrynet import analytics
-from lbrynet import conf
-from lbrynet.core import utils
-from lbrynet.core import log_support
-from lbrynet.daemon.auth.client import LBRYAPIClient
-from lbrynet.daemon.Daemon import Daemon
+from lbrynet import utils, conf, log_support
+from lbrynet.extras.daemon import analytics
+from lbrynet.extras.daemon.auth.client import LBRYAPIClient
+from lbrynet.extras.daemon.Daemon import Daemon
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/daemon/DaemonControl.py b/lbrynet/extras/daemon/DaemonControl.py
similarity index 90%
rename from lbrynet/daemon/DaemonControl.py
rename to lbrynet/extras/daemon/DaemonControl.py
index 65402531b..0ad0158fc 100644
--- a/lbrynet/daemon/DaemonControl.py
+++ b/lbrynet/extras/daemon/DaemonControl.py
@@ -7,16 +7,14 @@ if 'win' in sys.platform:
     import certifi
     os.environ['SSL_CERT_FILE'] = certifi.where()
 
-from lbrynet.core import log_support
 
 import argparse
 import logging.handlers
 
 from twisted.internet import reactor
-
-from lbrynet import conf
-from lbrynet.core import utils, system_info
-from lbrynet.daemon.Daemon import Daemon
+from lbrynet import utils, conf, log_support
+from lbrynet.extras import system_info
+from lbrynet.extras.daemon.Daemon import Daemon
 
 log = logging.getLogger(__name__)
 
@@ -54,7 +52,7 @@ def start(argv=None, conf_path=None):
         conf.settings.update({'use_auth_http': args.useauth}, data_types=(conf.TYPE_CLI,))
 
     if args.version:
-        version = system_info.get_platform(get_ip=False)
+        version = system_info.get_platform()
         version['installation_id'] = conf.settings.installation_id
         print(utils.json_dumps_pretty(version))
         return
diff --git a/lbrynet/daemon/Downloader.py b/lbrynet/extras/daemon/Downloader.py
similarity index 76%
rename from lbrynet/daemon/Downloader.py
rename to lbrynet/extras/daemon/Downloader.py
index 7d5b197de..45900e2f4 100644
--- a/lbrynet/daemon/Downloader.py
+++ b/lbrynet/extras/daemon/Downloader.py
@@ -1,19 +1,17 @@
 import logging
 import os
 from twisted.internet import defer
-from twisted.internet.task import LoopingCall
 
-from lbrynet.daemon.Components import f2d
-from lbryschema.fee import Fee
-
-from lbrynet.core.Error import InsufficientFundsError, KeyFeeAboveMaxAllowed, InvalidStreamDescriptorError
-from lbrynet.core.Error import DownloadDataTimeout, DownloadCanceledError, DownloadSDTimeout
-from lbrynet.core.utils import safe_start_looping_call, safe_stop_looping_call
-from lbrynet.core.StreamDescriptor import download_sd_blob
-from lbrynet.file_manager.EncryptedFileDownloader import ManagedEncryptedFileDownloaderFactory
 from lbrynet import conf
-from torba.constants import COIN
-from lbrynet.wallet.dewies import dewies_to_lbc
+from lbrynet.schema.fee import Fee
+
+from lbrynet.p2p.Error import InsufficientFundsError, KeyFeeAboveMaxAllowed, InvalidStreamDescriptorError
+from lbrynet.p2p.Error import DownloadDataTimeout, DownloadCanceledError
+from lbrynet.p2p.StreamDescriptor import download_sd_blob
+from lbrynet.blob.EncryptedFileDownloader import ManagedEncryptedFileDownloaderFactory
+from torba.client.constants import COIN
+from lbrynet.extras.wallet.dewies import dewies_to_lbc
+from lbrynet.extras.daemon.Components import f2d
 
 INITIALIZING_CODE = 'initializing'
 DOWNLOAD_METADATA_CODE = 'downloading_metadata'
@@ -34,8 +32,11 @@ log = logging.getLogger(__name__)
 
 class GetStream:
     def __init__(self, sd_identifier, wallet, exchange_rate_manager, blob_manager, peer_finder, rate_limiter,
-                 payment_rate_manager, storage, max_key_fee, disable_max_key_fee, data_rate=None, timeout=None):
-
+                 payment_rate_manager, storage, max_key_fee, disable_max_key_fee, data_rate=None, timeout=None,
+                 reactor=None):
+        if not reactor:
+            from twisted.internet import reactor
+        self.reactor = reactor
         self.timeout = timeout or conf.settings['download_timeout']
         self.data_rate = data_rate or conf.settings['data_rate']
         self.max_key_fee = max_key_fee or conf.settings['max_key_fee'][1]
@@ -53,44 +54,17 @@ class GetStream:
         self.sd_identifier = sd_identifier
         self.storage = storage
         self.downloader = None
-        self.checker = LoopingCall(self.check_status)
 
         # fired when the download is complete
         self.finished_deferred = None
         # fired after the metadata and the first data blob have been downloaded
         self.data_downloading_deferred = defer.Deferred(None)
+        self.wrote_data = False
 
     @property
     def download_path(self):
         return os.path.join(self.download_directory, self.downloader.file_name)
 
-    def _check_status(self, status):
-        if status.num_completed > 0 and not self.data_downloading_deferred.called:
-            self.data_downloading_deferred.callback(True)
-        if self.data_downloading_deferred.called:
-            safe_stop_looping_call(self.checker)
-        else:
-            log.debug("Waiting for stream data (%i seconds)", self.timeout_counter)
-
-    def check_status(self):
-        """
-        Check if we've got the first data blob in the stream yet
-        """
-        self.timeout_counter += 1
-        if self.timeout_counter > self.timeout:
-            if not self.data_downloading_deferred.called:
-                if self.downloader:
-                    err = DownloadDataTimeout(self.sd_hash)
-                else:
-                    err = DownloadSDTimeout(self.sd_hash)
-                self.data_downloading_deferred.errback(err)
-            safe_stop_looping_call(self.checker)
-        elif self.downloader:
-            d = self.downloader.status()
-            d.addCallback(self._check_status)
-        else:
-            log.debug("Waiting for stream descriptor (%i seconds)", self.timeout_counter)
-
     def convert_max_fee(self):
         currency, amount = self.max_key_fee['currency'], self.max_key_fee['amount']
         return self.exchange_rate_manager.convert_currency(currency, "LBC", amount)
@@ -151,18 +125,13 @@ class GetStream:
         else:
             defer.returnValue(None)
 
-    @defer.inlineCallbacks
     def finish(self, results, name):
         self.set_status(DOWNLOAD_STOPPED_CODE, name)
         log.info("Finished downloading lbry://%s (%s) --> %s", name, self.sd_hash[:6],
                  self.download_path)
-        safe_stop_looping_call(self.checker)
-        status = yield self.downloader.status()
-        self._check_status(status)
-        defer.returnValue(self.download_path)
+        return defer.succeed(self.download_path)
 
     def fail(self, err):
-        safe_stop_looping_call(self.checker)
         raise err
 
     @defer.inlineCallbacks
@@ -194,8 +163,10 @@ class GetStream:
         self.downloader = yield self._create_downloader(sd_blob, file_name=file_name)
         yield self.pay_key_fee(key_fee, name)
         yield self.storage.save_content_claim(self.downloader.stream_hash, "%s:%i" % (txid, nout))
-        log.info("Downloading lbry://%s (%s) --> %s", name, self.sd_hash[:6], self.download_path)
         self.finished_deferred = self.downloader.start()
+        self.downloader.download_manager.progress_manager.wrote_first_data.addCallback(
+            self.data_downloading_deferred.callback
+        )
         self.finished_deferred.addCallbacks(lambda result: self.finish(result, name), self.fail)
 
     @defer.inlineCallbacks
@@ -211,16 +182,19 @@ class GetStream:
         """
         self.set_status(INITIALIZING_CODE, name)
         key_fee = yield self._initialize(stream_info)
-
-        safe_start_looping_call(self.checker, 1)
         self.set_status(DOWNLOAD_METADATA_CODE, name)
         try:
             sd_blob = yield self._download_sd_blob()
             yield self._download(sd_blob, name, key_fee, txid, nout, file_name)
             self.set_status(DOWNLOAD_RUNNING_CODE, name)
-            yield self.data_downloading_deferred
+            log.info("Downloading lbry://%s (%s) --> %s", name, self.sd_hash[:6], self.download_path)
+            self.data_downloading_deferred.addTimeout(self.timeout, self.reactor)
+            try:
+                yield self.data_downloading_deferred
+                self.wrote_data = True
+            except defer.TimeoutError:
+                raise DownloadDataTimeout("data download timed out")
         except (DownloadDataTimeout, InvalidStreamDescriptorError) as err:
-            safe_stop_looping_call(self.checker)
             raise err
 
         defer.returnValue((self.downloader, self.finished_deferred))
diff --git a/lbrynet/daemon/ExchangeRateManager.py b/lbrynet/extras/daemon/ExchangeRateManager.py
similarity index 98%
rename from lbrynet/daemon/ExchangeRateManager.py
rename to lbrynet/extras/daemon/ExchangeRateManager.py
index 9f50d09bc..feeadd5f8 100644
--- a/lbrynet/daemon/ExchangeRateManager.py
+++ b/lbrynet/extras/daemon/ExchangeRateManager.py
@@ -6,7 +6,7 @@ import treq
 from twisted.internet import defer
 from twisted.internet.task import LoopingCall
 
-from lbrynet.core.Error import InvalidExchangeRateResponse, CurrencyConversionError
+from lbrynet.p2p.Error import InvalidExchangeRateResponse, CurrencyConversionError
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/dht/hashannouncer.py b/lbrynet/extras/daemon/HashAnnouncer.py
similarity index 98%
rename from lbrynet/dht/hashannouncer.py
rename to lbrynet/extras/daemon/HashAnnouncer.py
index d78e56ad2..819f890fa 100644
--- a/lbrynet/dht/hashannouncer.py
+++ b/lbrynet/extras/daemon/HashAnnouncer.py
@@ -2,8 +2,7 @@ import binascii
 import logging
 
 from twisted.internet import defer, task
-from lbrynet.core import utils
-from lbrynet import conf
+from lbrynet import utils, conf
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/dht/peerfinder.py b/lbrynet/extras/daemon/PeerFinder.py
similarity index 60%
rename from lbrynet/dht/peerfinder.py
rename to lbrynet/extras/daemon/PeerFinder.py
index a20cd828c..2934b13f5 100644
--- a/lbrynet/dht/peerfinder.py
+++ b/lbrynet/extras/daemon/PeerFinder.py
@@ -4,7 +4,6 @@ import logging
 from twisted.internet import defer
 from lbrynet import conf
 
-
 log = logging.getLogger(__name__)
 
 
@@ -19,13 +18,12 @@ class DHTPeerFinder(DummyPeerFinder):
     """This class finds peers which have announced to the DHT that they have certain blobs"""
     #implements(IPeerFinder)
 
-    def __init__(self, dht_node, peer_manager):
+    def __init__(self, component_manager):
         """
-        dht_node - an instance of dht.Node class
-        peer_manager - an instance of PeerManager class
+        component_manager - an instance of ComponentManager
         """
-        self.dht_node = dht_node
-        self.peer_manager = peer_manager
+        self.component_manager = component_manager
+        self.peer_manager = component_manager.peer_manager
         self.peers = {}
         self._ongoing_searchs = {}
 
@@ -40,19 +38,30 @@ class DHTPeerFinder(DummyPeerFinder):
         Returns:
         list of peers for the blob
         """
-        self.peers.setdefault(blob_hash, {(self.dht_node.externalIP, self.dht_node.peerPort,)})
+        if "dht" in self.component_manager.skip_components:
+            return defer.succeed([])
+        if not self.component_manager.all_components_running("dht"):
+            return defer.succeed([])
+        dht_node = self.component_manager.get_component("dht")
+
+        self.peers.setdefault(blob_hash, {(dht_node.externalIP, dht_node.peerPort,)})
         if not blob_hash in self._ongoing_searchs or self._ongoing_searchs[blob_hash].called:
-            self._ongoing_searchs[blob_hash] = self._execute_peer_search(blob_hash, timeout)
-        peers = set(self._filter_self(blob_hash) if filter_self else self.peers[blob_hash])
+            self._ongoing_searchs[blob_hash] = self._execute_peer_search(dht_node, blob_hash, timeout)
+
+        def _filter_self(blob_hash):
+            my_host, my_port = dht_node.externalIP, dht_node.peerPort
+            return {(host, port) for host, port in self.peers[blob_hash] if (host, port) != (my_host, my_port)}
+
+        peers = set(_filter_self(blob_hash) if filter_self else self.peers[blob_hash])
         return defer.succeed([self.peer_manager.get_peer(*peer) for peer in peers])
 
     @defer.inlineCallbacks
-    def _execute_peer_search(self, blob_hash, timeout):
+    def _execute_peer_search(self, dht_node, blob_hash, timeout):
         bin_hash = binascii.unhexlify(blob_hash)
-        finished_deferred = self.dht_node.iterativeFindValue(bin_hash, exclude=self.peers[blob_hash])
+        finished_deferred = dht_node.iterativeFindValue(bin_hash, exclude=self.peers[blob_hash])
         timeout = timeout or conf.settings['peer_search_timeout']
         if timeout:
-            finished_deferred.addTimeout(timeout, self.dht_node.clock)
+            finished_deferred.addTimeout(timeout, dht_node.clock)
         try:
             peer_list = yield finished_deferred
             self.peers[blob_hash].update({(host, port) for _, host, port in peer_list})
@@ -60,7 +69,3 @@ class DHTPeerFinder(DummyPeerFinder):
             log.debug("DHT timed out while looking peers for blob %s after %s seconds", blob_hash, timeout)
         finally:
             del self._ongoing_searchs[blob_hash]
-
-    def _filter_self(self, blob_hash):
-        my_host, my_port = self.dht_node.externalIP, self.dht_node.peerPort
-        return {(host, port) for host, port in self.peers[blob_hash] if (host, port) != (my_host, my_port)}
diff --git a/lbrynet/core/PeerManager.py b/lbrynet/extras/daemon/PeerManager.py
similarity index 89%
rename from lbrynet/core/PeerManager.py
rename to lbrynet/extras/daemon/PeerManager.py
index 66e6214df..4cb1425ba 100644
--- a/lbrynet/core/PeerManager.py
+++ b/lbrynet/extras/daemon/PeerManager.py
@@ -1,4 +1,4 @@
-from lbrynet.core.Peer import Peer
+from lbrynet.p2p.Peer import Peer
 
 
 class PeerManager:
diff --git a/lbrynet/daemon/Publisher.py b/lbrynet/extras/daemon/Publisher.py
similarity index 97%
rename from lbrynet/daemon/Publisher.py
rename to lbrynet/extras/daemon/Publisher.py
index 39ce1c908..34d123a0c 100644
--- a/lbrynet/daemon/Publisher.py
+++ b/lbrynet/extras/daemon/Publisher.py
@@ -3,7 +3,7 @@ import logging
 import mimetypes
 import os
 
-from lbrynet.file_manager.EncryptedFileCreator import create_lbry_file
+from lbrynet.blob.EncryptedFileCreator import create_lbry_file
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/extras/daemon/__init__.py b/lbrynet/extras/daemon/__init__.py
new file mode 100644
index 000000000..9fb57d0d9
--- /dev/null
+++ b/lbrynet/extras/daemon/__init__.py
@@ -0,0 +1 @@
+from lbrynet.extras.daemon import Components  # register Component classes
diff --git a/lbrynet/analytics.py b/lbrynet/extras/daemon/analytics.py
similarity index 98%
rename from lbrynet/analytics.py
rename to lbrynet/extras/daemon/analytics.py
index 10de2bbaa..0208d6757 100644
--- a/lbrynet/analytics.py
+++ b/lbrynet/extras/daemon/analytics.py
@@ -4,8 +4,8 @@ import logging
 import treq
 from twisted.internet import defer, task
 
-from lbrynet import conf
-from lbrynet.core import looping_call_manager, utils, system_info
+from lbrynet import conf, utils
+from lbrynet.extras import looping_call_manager, system_info
 
 # Things We Track
 SERVER_STARTUP = 'Server Startup'
@@ -136,8 +136,8 @@ class Manager:
 
     def _get_looping_calls(self):
         return [
-            ('send_heartbeat', self._send_heartbeat, 60),
-            ('update_tracked_metrics', self._update_tracked_metrics, 300),
+            ('send_heartbeat', self._send_heartbeat, 300),
+            ('update_tracked_metrics', self._update_tracked_metrics, 600),
         ]
 
     def _setup_looping_calls(self):
diff --git a/lbrynet/cryptstream/client/__init__.py b/lbrynet/extras/daemon/auth/__init__.py
similarity index 100%
rename from lbrynet/cryptstream/client/__init__.py
rename to lbrynet/extras/daemon/auth/__init__.py
diff --git a/lbrynet/daemon/auth/auth.py b/lbrynet/extras/daemon/auth/auth.py
similarity index 95%
rename from lbrynet/daemon/auth/auth.py
rename to lbrynet/extras/daemon/auth/auth.py
index 5fb5cd2e7..8e350589a 100644
--- a/lbrynet/daemon/auth/auth.py
+++ b/lbrynet/extras/daemon/auth/auth.py
@@ -3,7 +3,7 @@ from zope.interface import implementer
 from twisted.cred import portal, checkers, credentials, error as cred_error
 from twisted.internet import defer
 from twisted.web import resource
-from .keyring import Keyring
+from lbrynet.extras.daemon.auth.keyring import Keyring
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/daemon/auth/client.py b/lbrynet/extras/daemon/auth/client.py
similarity index 98%
rename from lbrynet/daemon/auth/client.py
rename to lbrynet/extras/daemon/auth/client.py
index e6b3c63b6..50b0def8b 100644
--- a/lbrynet/daemon/auth/client.py
+++ b/lbrynet/extras/daemon/auth/client.py
@@ -4,7 +4,7 @@ import logging
 from urllib.parse import urlparse
 
 from lbrynet import conf
-from lbrynet.daemon.auth.keyring import Keyring, APIKey
+from lbrynet.extras.daemon.auth.keyring import Keyring, APIKey
 
 log = logging.getLogger(__name__)
 USER_AGENT = "AuthServiceProxy/0.1"
diff --git a/lbrynet/daemon/auth/factory.py b/lbrynet/extras/daemon/auth/factory.py
similarity index 88%
rename from lbrynet/daemon/auth/factory.py
rename to lbrynet/extras/daemon/auth/factory.py
index 549b9bd68..77f573baa 100644
--- a/lbrynet/daemon/auth/factory.py
+++ b/lbrynet/extras/daemon/auth/factory.py
@@ -4,8 +4,8 @@ from twisted.web import server, guard, resource
 from twisted.cred import portal
 
 from lbrynet import conf
-from .auth import PasswordChecker, HttpPasswordRealm
-from ..auth.keyring import Keyring
+from lbrynet.extras.daemon.auth.auth import PasswordChecker, HttpPasswordRealm
+from lbrynet.extras.daemon.auth.keyring import Keyring
 
 log = logging.getLogger(__name__)
 
@@ -42,7 +42,7 @@ class AuthJSONRPCResource(resource.Resource):
             realm = HttpPasswordRealm(self)
             portal_to_realm = portal.Portal(realm, [checker, ])
             root = guard.HTTPAuthSessionWrapper(
-                portal_to_realm, [guard.BasicCredentialFactory('Login to lbrynet api'), ]
+                portal_to_realm, [guard.BasicCredentialFactory(b'Login to lbrynet api'), ]
             )
         else:
             log.info("Using non-authenticated API")
diff --git a/lbrynet/daemon/auth/keyring.py b/lbrynet/extras/daemon/auth/keyring.py
similarity index 99%
rename from lbrynet/daemon/auth/keyring.py
rename to lbrynet/extras/daemon/auth/keyring.py
index 91d9290a1..eb4f7011a 100644
--- a/lbrynet/daemon/auth/keyring.py
+++ b/lbrynet/extras/daemon/auth/keyring.py
@@ -3,6 +3,7 @@ import datetime
 import hmac
 import hashlib
 import base58
+import logging
 from OpenSSL.crypto import FILETYPE_PEM
 from ssl import create_default_context, SSLContext
 from cryptography.hazmat.backends import default_backend
@@ -12,7 +13,7 @@ from cryptography.x509.name import NameOID, NameAttribute
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization
 from twisted.internet import ssl
-import logging
+
 from lbrynet import conf
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/daemon/auth/server.py b/lbrynet/extras/daemon/auth/server.py
similarity index 96%
rename from lbrynet/daemon/auth/server.py
rename to lbrynet/extras/daemon/auth/server.py
index e06e8a740..e275b09bb 100644
--- a/lbrynet/daemon/auth/server.py
+++ b/lbrynet/extras/daemon/auth/server.py
@@ -1,10 +1,9 @@
 import asyncio
 import logging
-from six.moves.urllib import parse as urlparse
+from urllib import parse as urlparse
 import json
 import inspect
 import signal
-
 from functools import wraps
 from twisted.web import server
 from twisted.internet import defer
@@ -14,16 +13,17 @@ from twisted.internet.error import ConnectionDone, ConnectionLost
 from txjsonrpc import jsonrpclib
 from traceback import format_exc
 
-from lbrynet import conf, analytics
-from lbrynet.core.Error import InvalidAuthenticationToken
-from lbrynet.core import utils
-from lbrynet.core.Error import ComponentsNotStarted, ComponentStartConditionNotMet
-from lbrynet.core.looping_call_manager import LoopingCallManager
-from lbrynet.daemon.ComponentManager import ComponentManager
-from .keyring import APIKey, Keyring
-from .undecorated import undecorated
-from .factory import AuthJSONRPCResource
-from lbrynet.daemon.json_response_encoder import JSONResponseEncoder
+from lbrynet import conf, utils
+from lbrynet.extras.daemon import analytics
+from lbrynet.p2p.Error import InvalidAuthenticationToken
+from lbrynet.p2p.Error import ComponentsNotStarted, ComponentStartConditionNotMet
+from lbrynet.extras.looping_call_manager import LoopingCallManager
+from lbrynet.extras.daemon.ComponentManager import ComponentManager
+from lbrynet.extras.daemon.auth.keyring import APIKey, Keyring
+from lbrynet.extras.daemon.auth.undecorated import undecorated
+from lbrynet.extras.daemon.auth.factory import AuthJSONRPCResource
+from lbrynet.extras.daemon.json_response_encoder import JSONResponseEncoder
+
 log = logging.getLogger(__name__)
 
 EMPTY_PARAMS = [{}]
@@ -206,7 +206,6 @@ class AuthJSONRPCServer(AuthorizedBase):
         self.announced_startup = False
         self.sessions = {}
         self.server = None
-        self.keyring = Keyring.generate_and_save()
 
     @defer.inlineCallbacks
     def start_listening(self):
@@ -284,7 +283,10 @@ class AuthJSONRPCServer(AuthorizedBase):
         return d
 
     def get_server_factory(self):
-        return AuthJSONRPCResource(self).getServerFactory(self.keyring, self._use_authentication, self._use_https)
+        keyring = None
+        if self._use_authentication or self._use_https:
+            keyring = Keyring.generate_and_save()
+        return AuthJSONRPCResource(self).getServerFactory(keyring, self._use_authentication, self._use_https)
 
     def _set_headers(self, request, data, update_secret=False):
         if conf.settings['allowed_origin']:
diff --git a/lbrynet/daemon/auth/undecorated.py b/lbrynet/extras/daemon/auth/undecorated.py
similarity index 100%
rename from lbrynet/daemon/auth/undecorated.py
rename to lbrynet/extras/daemon/auth/undecorated.py
diff --git a/lbrynet/daemon/json_response_encoder.py b/lbrynet/extras/daemon/json_response_encoder.py
similarity index 86%
rename from lbrynet/daemon/json_response_encoder.py
rename to lbrynet/extras/daemon/json_response_encoder.py
index a265bd8f9..bad96e6e1 100644
--- a/lbrynet/daemon/json_response_encoder.py
+++ b/lbrynet/extras/daemon/json_response_encoder.py
@@ -1,11 +1,15 @@
+import logging
 from decimal import Decimal
 from binascii import hexlify
 from datetime import datetime
 from json import JSONEncoder
 from ecdsa import BadSignatureError
-from lbrynet.wallet.transaction import Transaction, Output
-from lbrynet.wallet.dewies import dewies_to_lbc
-from lbrynet.wallet.ledger import MainNetLedger
+from lbrynet.extras.wallet import MainNetLedger
+from lbrynet.extras.wallet.transaction import Transaction, Output
+from lbrynet.extras.wallet.dewies import dewies_to_lbc
+
+
+log = logging.getLogger(__name__)
 
 
 class JSONResponseEncoder(JSONEncoder):
@@ -75,6 +79,12 @@ class JSONResponseEncoder(JSONEncoder):
                             )
                         except BadSignatureError:
                             output['valid_signature'] = False
+                        except ValueError:
+                            log.exception(
+                                'txo.id: %s, txo.channel.id:%s, output: %s',
+                                txo.id, txo.channel.id, output
+                            )
+                            output['valid_signature'] = False
 
             if txo.script.is_claim_name:
                 output['type'] = 'claim'
diff --git a/lbrynet/daemon/auth/__init__.py b/lbrynet/extras/daemon/migrator/__init__.py
similarity index 100%
rename from lbrynet/daemon/auth/__init__.py
rename to lbrynet/extras/daemon/migrator/__init__.py
diff --git a/lbrynet/database/migrator/dbmigrator.py b/lbrynet/extras/daemon/migrator/dbmigrator.py
similarity index 65%
rename from lbrynet/database/migrator/dbmigrator.py
rename to lbrynet/extras/daemon/migrator/dbmigrator.py
index 44e8d417d..5ec93712c 100644
--- a/lbrynet/database/migrator/dbmigrator.py
+++ b/lbrynet/extras/daemon/migrator/dbmigrator.py
@@ -7,21 +7,21 @@ def migrate_db(db_dir, start, end):
     current = start
     while current < end:
         if current == 1:
-            from lbrynet.database.migrator.migrate1to2 import do_migration
+            from .migrate1to2 import do_migration
         elif current == 2:
-            from lbrynet.database.migrator.migrate2to3 import do_migration
+            from .migrate2to3 import do_migration
         elif current == 3:
-            from lbrynet.database.migrator.migrate3to4 import do_migration
+            from .migrate3to4 import do_migration
         elif current == 4:
-            from lbrynet.database.migrator.migrate4to5 import do_migration
+            from .migrate4to5 import do_migration
         elif current == 5:
-            from lbrynet.database.migrator.migrate5to6 import do_migration
+            from .migrate5to6 import do_migration
         elif current == 6:
-            from lbrynet.database.migrator.migrate6to7 import do_migration
+            from .migrate6to7 import do_migration
         elif current == 7:
-            from lbrynet.database.migrator.migrate7to8 import do_migration
+            from .migrate7to8 import do_migration
         elif current == 8:
-            from lbrynet.database.migrator.migrate8to9 import do_migration
+            from .migrate8to9 import do_migration
         else:
             raise Exception("DB migration of version {} to {} is not available".format(current,
                                                                                        current+1))
diff --git a/lbrynet/database/migrator/migrate1to2.py b/lbrynet/extras/daemon/migrator/migrate1to2.py
similarity index 100%
rename from lbrynet/database/migrator/migrate1to2.py
rename to lbrynet/extras/daemon/migrator/migrate1to2.py
diff --git a/lbrynet/database/migrator/migrate2to3.py b/lbrynet/extras/daemon/migrator/migrate2to3.py
similarity index 100%
rename from lbrynet/database/migrator/migrate2to3.py
rename to lbrynet/extras/daemon/migrator/migrate2to3.py
diff --git a/lbrynet/database/migrator/migrate3to4.py b/lbrynet/extras/daemon/migrator/migrate3to4.py
similarity index 100%
rename from lbrynet/database/migrator/migrate3to4.py
rename to lbrynet/extras/daemon/migrator/migrate3to4.py
diff --git a/lbrynet/database/migrator/migrate4to5.py b/lbrynet/extras/daemon/migrator/migrate4to5.py
similarity index 100%
rename from lbrynet/database/migrator/migrate4to5.py
rename to lbrynet/extras/daemon/migrator/migrate4to5.py
diff --git a/lbrynet/database/migrator/migrate5to6.py b/lbrynet/extras/daemon/migrator/migrate5to6.py
similarity index 99%
rename from lbrynet/database/migrator/migrate5to6.py
rename to lbrynet/extras/daemon/migrator/migrate5to6.py
index ca03d3fc8..d8dcacdb5 100644
--- a/lbrynet/database/migrator/migrate5to6.py
+++ b/lbrynet/extras/daemon/migrator/migrate5to6.py
@@ -2,8 +2,8 @@ import sqlite3
 import os
 import json
 import logging
-from lbryschema.decode import smart_decode
 from lbrynet import conf
+from lbrynet.schema.decode import smart_decode
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/database/migrator/migrate6to7.py b/lbrynet/extras/daemon/migrator/migrate6to7.py
similarity index 100%
rename from lbrynet/database/migrator/migrate6to7.py
rename to lbrynet/extras/daemon/migrator/migrate6to7.py
diff --git a/lbrynet/database/migrator/migrate7to8.py b/lbrynet/extras/daemon/migrator/migrate7to8.py
similarity index 100%
rename from lbrynet/database/migrator/migrate7to8.py
rename to lbrynet/extras/daemon/migrator/migrate7to8.py
diff --git a/lbrynet/database/migrator/migrate8to9.py b/lbrynet/extras/daemon/migrator/migrate8to9.py
similarity index 90%
rename from lbrynet/database/migrator/migrate8to9.py
rename to lbrynet/extras/daemon/migrator/migrate8to9.py
index a518e9899..b97a8651e 100644
--- a/lbrynet/database/migrator/migrate8to9.py
+++ b/lbrynet/extras/daemon/migrator/migrate8to9.py
@@ -2,9 +2,9 @@ import sqlite3
 import logging
 import os
 
-from lbrynet.core.Error import InvalidStreamDescriptorError
-from lbrynet.core.StreamDescriptor import EncryptedFileStreamType, format_sd_info, format_blobs, validate_descriptor
-from lbrynet.cryptstream.CryptBlob import CryptBlobInfo
+from lbrynet.p2p.Error import InvalidStreamDescriptorError
+from lbrynet.p2p.StreamDescriptor import EncryptedFileStreamType, format_sd_info, format_blobs, validate_descriptor
+from lbrynet.blob.CryptBlob import CryptBlobInfo
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/database/storage.py b/lbrynet/extras/daemon/storage.py
similarity index 97%
rename from lbrynet/database/storage.py
rename to lbrynet/extras/daemon/storage.py
index 56643d0de..25065e84c 100644
--- a/lbrynet/database/storage.py
+++ b/lbrynet/extras/daemon/storage.py
@@ -6,13 +6,13 @@ from binascii import hexlify, unhexlify
 from decimal import Decimal
 from twisted.internet import defer, task, threads
 from twisted.enterprise import adbapi
+from torba.client.constants import COIN
 
-from lbryschema.claim import ClaimDict
-from lbryschema.decode import smart_decode
 from lbrynet import conf
-from lbrynet.cryptstream.CryptBlob import CryptBlobInfo
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.schema.decode import smart_decode
+from lbrynet.blob.CryptBlob import CryptBlobInfo
 from lbrynet.dht.constants import dataExpireTimeout
-from torba.constants import COIN
 
 log = logging.getLogger(__name__)
 
@@ -418,7 +418,7 @@ class SQLiteStorage:
 
     def check_if_stream_exists(self, stream_hash):
         d = self.db.runQuery("select stream_hash from stream where stream_hash=?", (stream_hash, ))
-        d.addCallback(lambda r: True if len(r) else False)
+        d.addCallback(lambda r: bool(len(r)))
         return d
 
     def get_blob_num_by_hash(self, stream_hash, blob_hash):
@@ -573,16 +573,13 @@ class SQLiteStorage:
             }
 
         def _get_supports(transaction):
-            if len(claim_ids) == 1:
-                bind = "=?"
-            else:
-                bind = "in ({})".format(','.join('?' for _ in range(len(claim_ids))))
             return [
                 _format_support(*support_info)
-                for support_info in transaction.execute(
-                    f"select * from support where claim_id {bind}",
+                for support_info in _batched_select(
+                    transaction,
+                    "select * from support where claim_id in {}",
                     tuple(claim_ids)
-                ).fetchall()
+                )
             ]
 
         return self.db.runInteraction(_get_supports)
@@ -756,28 +753,27 @@ class SQLiteStorage:
     def get_claims_from_stream_hashes(self, stream_hashes, include_supports=True):
         def _batch_get_claim(transaction):
             results = {}
-            bind = "({})".format(','.join('?' for _ in range(len(stream_hashes))))
-            claim_infos = transaction.execute(
+            claim_infos = _batched_select(
+                transaction,
                 "select content_claim.stream_hash, c.* from content_claim "
                 "inner join claim c on c.claim_outpoint=content_claim.claim_outpoint "
-                "and content_claim.stream_hash in {} order by c.rowid desc".format(bind),
-                tuple(stream_hashes)
-            ).fetchall()
+                "and content_claim.stream_hash in {} order by c.rowid desc",
+                stream_hashes)
             channel_id_infos = {}
             for claim_info in claim_infos:
                 if claim_info[7]:
                     streams = channel_id_infos.get(claim_info[7], [])
                     streams.append(claim_info[0])
                     channel_id_infos[claim_info[7]] = streams
-            for claim_info in claim_infos:
                 stream_hash = claim_info[0]
                 result = _format_claim_response(*claim_info[1:])
                 results[stream_hash] = result
-            bind = "({})".format(','.join('?' for _ in range(len(channel_id_infos))))
-            for claim_id, channel_name in transaction.execute(
-                    f"select claim_id, claim_name from claim where claim_id in {bind}",
-                    tuple(channel_id_infos.keys())
-            ).fetchall():
+            channel_names = _batched_select(
+                transaction,
+                "select claim_id, claim_name from claim where claim_id in {}",
+                tuple(channel_id_infos.keys())
+            )
+            for claim_id, channel_name in channel_names:
                 for stream_hash in channel_id_infos[claim_id]:
                     results[stream_hash]['channel_name'] = channel_name
             return results
@@ -892,3 +888,11 @@ def _format_claim_response(outpoint, claim_id, name, amount, height, serialized,
         "channel_name": None
     }
     return r
+
+
+def _batched_select(transaction, query, parameters):
+    for start_index in range(0, len(parameters), 900):
+        current_batch = parameters[start_index:start_index+900]
+        bind = "({})".format(','.join(['?'] * len(current_batch)))
+        for result in transaction.execute(query.format(bind), current_batch):
+            yield result
diff --git a/lbrynet/core/looping_call_manager.py b/lbrynet/extras/looping_call_manager.py
similarity index 100%
rename from lbrynet/core/looping_call_manager.py
rename to lbrynet/extras/looping_call_manager.py
diff --git a/lbrynet/reflector/__init__.py b/lbrynet/extras/reflector/__init__.py
similarity index 88%
rename from lbrynet/reflector/__init__.py
rename to lbrynet/extras/reflector/__init__.py
index 06dd0b4e9..56f9bfdf6 100644
--- a/lbrynet/reflector/__init__.py
+++ b/lbrynet/extras/reflector/__init__.py
@@ -63,7 +63,3 @@ If the transfer was not successful (False), the blob is re-added to the needed_b
 Blob requests continue for each of the blobs the client has queued to send, when completed
 the client disconnects.
 """
-
-from lbrynet.reflector.server.server import ReflectorServerFactory as ServerFactory
-from lbrynet.reflector.client.client import EncryptedFileReflectorClientFactory as ClientFactory
-from lbrynet.reflector.client.blob import BlobReflectorClientFactory as BlobClientFactory
diff --git a/lbrynet/database/__init__.py b/lbrynet/extras/reflector/client/__init__.py
similarity index 100%
rename from lbrynet/database/__init__.py
rename to lbrynet/extras/reflector/client/__init__.py
diff --git a/lbrynet/reflector/client/blob.py b/lbrynet/extras/reflector/client/blob.py
similarity index 99%
rename from lbrynet/reflector/client/blob.py
rename to lbrynet/extras/reflector/client/blob.py
index 54497cc46..38b32b6d0 100644
--- a/lbrynet/reflector/client/blob.py
+++ b/lbrynet/extras/reflector/client/blob.py
@@ -5,7 +5,7 @@ from twisted.protocols.basic import FileSender
 from twisted.internet.protocol import Protocol, ClientFactory
 from twisted.internet import defer, error
 
-from lbrynet.reflector.common import IncompleteResponse, REFLECTOR_V2
+from lbrynet.extras.reflector.common import IncompleteResponse, REFLECTOR_V2
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/reflector/client/client.py b/lbrynet/extras/reflector/client/client.py
similarity index 98%
rename from lbrynet/reflector/client/client.py
rename to lbrynet/extras/reflector/client/client.py
index 977d92670..213b33f69 100644
--- a/lbrynet/reflector/client/client.py
+++ b/lbrynet/extras/reflector/client/client.py
@@ -6,8 +6,8 @@ from twisted.protocols.basic import FileSender
 from twisted.internet.protocol import Protocol, ClientFactory
 from twisted.internet import defer, error
 
-from lbrynet.reflector.common import IncompleteResponse, ReflectorRequestError
-from lbrynet.reflector.common import REFLECTOR_V1, REFLECTOR_V2
+from lbrynet.extras.reflector.common import IncompleteResponse, ReflectorRequestError
+from lbrynet.extras.reflector.common import REFLECTOR_V1, REFLECTOR_V2
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/reflector/common.py b/lbrynet/extras/reflector/common.py
similarity index 100%
rename from lbrynet/reflector/common.py
rename to lbrynet/extras/reflector/common.py
diff --git a/lbrynet/reflector/reupload.py b/lbrynet/extras/reflector/reupload.py
similarity index 90%
rename from lbrynet/reflector/reupload.py
rename to lbrynet/extras/reflector/reupload.py
index e770cc883..1a6567d27 100644
--- a/lbrynet/reflector/reupload.py
+++ b/lbrynet/extras/reflector/reupload.py
@@ -2,7 +2,8 @@ import random
 
 from twisted.internet import reactor, defer
 from lbrynet import conf
-from lbrynet.reflector import ClientFactory, BlobClientFactory
+from lbrynet.extras.reflector.client.client import EncryptedFileReflectorClientFactory
+from lbrynet.extras.reflector.client.blob import BlobReflectorClientFactory
 
 
 def _is_ip(host):
@@ -26,7 +27,7 @@ def resolve(host):
 @defer.inlineCallbacks
 def _reflect_stream(blob_manager, stream_hash, sd_hash, reflector_server):
     reflector_address, reflector_port = reflector_server[0], reflector_server[1]
-    factory = ClientFactory(blob_manager, stream_hash, sd_hash)
+    factory = EncryptedFileReflectorClientFactory(blob_manager, stream_hash, sd_hash)
     ip = yield resolve(reflector_address)
     yield reactor.connectTCP(ip, reflector_port, factory)
     result = yield factory.finished_deferred
@@ -40,7 +41,7 @@ def _reflect_file(lbry_file, reflector_server):
 @defer.inlineCallbacks
 def _reflect_blobs(blob_manager, blob_hashes, reflector_server):
     reflector_address, reflector_port = reflector_server[0], reflector_server[1]
-    factory = BlobClientFactory(blob_manager, blob_hashes)
+    factory = BlobReflectorClientFactory(blob_manager, blob_hashes)
     ip = yield resolve(reflector_address)
     yield reactor.connectTCP(ip, reflector_port, factory)
     result = yield factory.finished_deferred
diff --git a/lbrynet/database/migrator/__init__.py b/lbrynet/extras/reflector/server/__init__.py
similarity index 100%
rename from lbrynet/database/migrator/__init__.py
rename to lbrynet/extras/reflector/server/__init__.py
diff --git a/lbrynet/reflector/server/server.py b/lbrynet/extras/reflector/server/server.py
similarity index 96%
rename from lbrynet/reflector/server/server.py
rename to lbrynet/extras/reflector/server/server.py
index 289e0e036..f51869e38 100644
--- a/lbrynet/reflector/server/server.py
+++ b/lbrynet/extras/reflector/server/server.py
@@ -3,12 +3,12 @@ import json
 from twisted.python import failure
 from twisted.internet import error, defer
 from twisted.internet.protocol import Protocol, ServerFactory
-from lbrynet.core.utils import is_valid_blobhash
-from lbrynet.core.Error import DownloadCanceledError, InvalidBlobHashError
-from lbrynet.core.StreamDescriptor import BlobStreamDescriptorReader
-from lbrynet.core.StreamDescriptor import save_sd_info
-from lbrynet.reflector.common import REFLECTOR_V1, REFLECTOR_V2
-from lbrynet.reflector.common import ReflectorRequestError, ReflectorClientVersionError
+from lbrynet.blob.blob_file import is_valid_blobhash
+from lbrynet.p2p.Error import DownloadCanceledError, InvalidBlobHashError
+from lbrynet.p2p.StreamDescriptor import BlobStreamDescriptorReader
+from lbrynet.p2p.StreamDescriptor import save_sd_info
+from lbrynet.extras.reflector.common import REFLECTOR_V1, REFLECTOR_V2
+from lbrynet.extras.reflector.common import ReflectorRequestError, ReflectorClientVersionError
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/extras/system_info.py b/lbrynet/extras/system_info.py
new file mode 100644
index 000000000..63fa3b065
--- /dev/null
+++ b/lbrynet/extras/system_info.py
@@ -0,0 +1,30 @@
+import platform
+import os
+import logging.handlers
+
+from lbrynet.schema import __version__ as schema_version
+from lbrynet import build_type, __version__ as lbrynet_version
+
+log = logging.getLogger(__name__)
+
+
+def get_platform() -> dict:
+    p = {
+        "processor": platform.processor(),
+        "python_version": platform.python_version(),
+        "platform": platform.platform(),
+        "os_release": platform.release(),
+        "os_system": platform.system(),
+        "lbrynet_version": lbrynet_version,
+        "lbryschema_version": schema_version,
+        "build": build_type.BUILD,  # CI server sets this during build step
+    }
+    if p["os_system"] == "Linux":
+        try:
+            import distro
+            p["distro"] = distro.info()
+            p["desktop"] = os.environ.get('XDG_CURRENT_DESKTOP', 'Unknown')
+        except ModuleNotFoundError:
+            pass
+
+    return p
diff --git a/lbrynet/extras/wallet/__init__.py b/lbrynet/extras/wallet/__init__.py
new file mode 100644
index 000000000..b2ee7b8a5
--- /dev/null
+++ b/lbrynet/extras/wallet/__init__.py
@@ -0,0 +1,11 @@
+__node_daemon__ = 'lbrycrdd'
+__node_cli__ = 'lbrycrd-cli'
+__node_bin__ = ''
+__node_url__ = (
+    'https://github.com/lbryio/lbrycrd/releases/download/v0.12.2.1/lbrycrd-linux.zip'
+)
+__spvserver__ = 'lbrynet.extras.wallet.server.coin.LBCRegTest'
+
+from lbrynet.extras.wallet.ledger import MainNetLedger, RegTestLedger
+from lbrynet.extras.wallet.manager import LbryWalletManager
+from lbrynet.extras.wallet.network import Network
diff --git a/lbrynet/wallet/account.py b/lbrynet/extras/wallet/account.py
similarity index 87%
rename from lbrynet/wallet/account.py
rename to lbrynet/extras/wallet/account.py
index 97988955e..94bbbe1e2 100644
--- a/lbrynet/wallet/account.py
+++ b/lbrynet/extras/wallet/account.py
@@ -1,11 +1,11 @@
 import json
 import logging
 
-from torba.baseaccount import BaseAccount
-from torba.basetransaction import TXORef
+from torba.client.baseaccount import BaseAccount
+from torba.client.basetransaction import TXORef
 
-from lbryschema.claim import ClaimDict
-from lbryschema.signer import SECP256k1, get_signer
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.schema.signer import SECP256k1, get_signer
 
 
 log = logging.getLogger(__name__)
@@ -95,7 +95,9 @@ class Account(BaseAccount):
                     txid, nout = maybe_claim_id.split(':')
                     tx = await self.ledger.db.get_transaction(txid=txid)
                     if not tx:
-                        log.warning("Claim migration failed to find a transaction for outpoint %s:%i")
+                        log.warning(
+                            "Claim migration failed to find a transaction for outpoint %s", maybe_claim_id
+                        )
                         results['previous-corrupted'] += 1
                         continue
                     if tx.outputs[int(nout)].script.is_claim_involved:
@@ -178,3 +180,24 @@ class Account(BaseAccount):
 
     def get_channel_count(self, **constraints):
         return self.ledger.db.get_channel_count(account=self, **constraints)
+
+    async def send_to_addresses(self, amount, addresses, broadcast=False):
+        tx_class = self.ledger.transaction_class
+        tx = await tx_class.create(
+            inputs=[],
+            outputs=[
+                tx_class.output_class.pay_pubkey_hash(amount, self.ledger.address_to_hash160(address))
+                for address in addresses
+            ],
+            funding_accounts=[self],
+            change_account=self
+        )
+
+        if broadcast:
+            await self.ledger.broadcast(tx)
+        else:
+            await self.ledger.release_outputs(
+                [txi.txo_ref.txo for txi in tx.inputs]
+            )
+
+        return tx
diff --git a/lbrynet/wallet/claim_proofs.py b/lbrynet/extras/wallet/claim_proofs.py
similarity index 94%
rename from lbrynet/wallet/claim_proofs.py
rename to lbrynet/extras/wallet/claim_proofs.py
index f84ac487b..dd1a2a29b 100644
--- a/lbrynet/wallet/claim_proofs.py
+++ b/lbrynet/extras/wallet/claim_proofs.py
@@ -1,7 +1,6 @@
-import six
 import struct
 import binascii
-from torba.hash import double_sha256
+from torba.client.hash import double_sha256
 
 
 class InvalidProofError(Exception):
@@ -17,7 +16,7 @@ def get_hash_for_outpoint(txhash, nout, height_of_last_takeover):
 
 
 # noinspection PyPep8
-def verify_proof(proof, rootHash, name):
+def verify_proof(proof, root_hash, name):
     previous_computed_hash = None
     reverse_computed_name = ''
     verified_value = False
@@ -32,7 +31,7 @@ def verify_proof(proof, rootHash, name):
                 if previous_child_character >= child['character']:
                     raise InvalidProofError("children not in increasing order")
             previous_child_character = child['character']
-            to_hash += six.int2byte(child['character'])
+            to_hash += bytes((child['character'],))
             if 'nodeHash' in child:
                 if len(child['nodeHash']) != 64:
                     raise InvalidProofError("invalid child nodeHash")
@@ -70,7 +69,7 @@ def verify_proof(proof, rootHash, name):
 
         previous_computed_hash = double_sha256(to_hash)
 
-    if previous_computed_hash != binascii.unhexlify(rootHash)[::-1]:
+    if previous_computed_hash != binascii.unhexlify(root_hash)[::-1]:
         raise InvalidProofError("computed hash does not match roothash")
     if 'txhash' in proof and 'nOut' in proof:
         if not verified_value:
diff --git a/lbrynet/wallet/database.py b/lbrynet/extras/wallet/database.py
similarity index 97%
rename from lbrynet/wallet/database.py
rename to lbrynet/extras/wallet/database.py
index acca6adb7..b81e88d0a 100644
--- a/lbrynet/wallet/database.py
+++ b/lbrynet/extras/wallet/database.py
@@ -1,4 +1,4 @@
-from torba.basedatabase import BaseDatabase
+from torba.client.basedatabase import BaseDatabase
 
 
 class WalletDatabase(BaseDatabase):
@@ -64,7 +64,7 @@ class WalletDatabase(BaseDatabase):
         if channel_ids:
             channels = {
                 txo.claim_id: txo for txo in
-                (await super().get_utxos(
+                (await self.get_claims(
                     my_account=my_account,
                     claim_id__in=channel_ids
                 ))
@@ -78,7 +78,7 @@ class WalletDatabase(BaseDatabase):
 
     @staticmethod
     def constrain_claims(constraints):
-        constraints['claim_type__any'] = {'is_claim': 1, 'is_update': 1}
+        constraints['claim_type__any'] = {'is_claim': 1, 'is_update': 1, 'is_support': 1}
 
     def get_claims(self, **constraints):
         self.constrain_claims(constraints)
diff --git a/lbrynet/extras/wallet/dewies.py b/lbrynet/extras/wallet/dewies.py
new file mode 100644
index 000000000..1dd85eae0
--- /dev/null
+++ b/lbrynet/extras/wallet/dewies.py
@@ -0,0 +1,33 @@
+import textwrap
+from torba.client.util import coins_to_satoshis, satoshis_to_coins
+
+
+def lbc_to_dewies(lbc):
+    try:
+        return coins_to_satoshis(lbc)
+    except ValueError:
+        raise ValueError(textwrap.dedent(
+            """
+            Decimal inputs require a value in the ones place and in the tenths place
+            separated by a period. The value provided, '{}', is not of the correct
+            format.
+
+            The following are examples of valid decimal inputs:
+
+            1.0
+            0.001
+            2.34500
+            4534.4
+            2323434.0000
+
+            The following are NOT valid:
+
+            83
+            .456
+            123.
+            """.format(lbc)
+        ))
+
+
+def dewies_to_lbc(dewies):
+    return satoshis_to_coins(dewies)
diff --git a/lbrynet/wallet/header.py b/lbrynet/extras/wallet/header.py
similarity index 95%
rename from lbrynet/wallet/header.py
rename to lbrynet/extras/wallet/header.py
index 9daeafc5b..6ef0f0213 100644
--- a/lbrynet/wallet/header.py
+++ b/lbrynet/extras/wallet/header.py
@@ -2,9 +2,9 @@ import struct
 from typing import Optional
 from binascii import hexlify, unhexlify
 
-from torba.baseheader import BaseHeaders
-from torba.util import ArithUint256
-from torba.hash import sha512, double_sha256, ripemd160
+from torba.client.baseheader import BaseHeaders
+from torba.client.util import ArithUint256
+from torba.client.hash import sha512, double_sha256, ripemd160
 
 
 class Headers(BaseHeaders):
diff --git a/lbrynet/wallet/ledger.py b/lbrynet/extras/wallet/ledger.py
similarity index 71%
rename from lbrynet/wallet/ledger.py
rename to lbrynet/extras/wallet/ledger.py
index 992a43e7e..40bbe295e 100644
--- a/lbrynet/wallet/ledger.py
+++ b/lbrynet/extras/wallet/ledger.py
@@ -2,16 +2,17 @@ import asyncio
 import logging
 from binascii import unhexlify
 
-from lbryschema.error import URIParseError
-from lbryschema.uri import parse_lbry_uri
-from torba.baseledger import BaseLedger
-
-from .resolve import Resolver
-from .account import Account
-from .network import Network
-from .database import WalletDatabase
-from .transaction import Transaction
-from .header import Headers, UnvalidatedHeaders
+from lbrynet.schema.validator import validate_claim_id
+from torba.client.baseledger import BaseLedger
+from lbrynet.schema.error import URIParseError
+from lbrynet.schema.uri import parse_lbry_uri
+from lbrynet.extras.wallet.dewies import dewies_to_lbc
+from lbrynet.extras.wallet.resolve import Resolver
+from lbrynet.extras.wallet.account import Account
+from lbrynet.extras.wallet.network import Network
+from lbrynet.extras.wallet.database import WalletDatabase
+from lbrynet.extras.wallet.transaction import Transaction
+from lbrynet.extras.wallet.header import Headers, UnvalidatedHeaders
 
 
 log = logging.getLogger(__name__)
@@ -56,11 +57,18 @@ class MainNetLedger(BaseLedger):
     async def resolve(self, page, page_size, *uris):
         for uri in uris:
             try:
-                parse_lbry_uri(uri)
+                parsed_uri = parse_lbry_uri(uri)
+                if parsed_uri.claim_id:
+                    validate_claim_id(parsed_uri.claim_id)
             except URIParseError as err:
                 return {'error': err.args[0]}
-        resolutions = await self.network.get_values_for_uris(self.headers.hash().decode(), *uris)
-        return await self.resolver._handle_resolutions(resolutions, uris, page, page_size)
+            except Exception as e:
+                return {'error': str(e)}
+        try:
+            resolutions = await self.network.get_values_for_uris(self.headers.hash().decode(), *uris)
+            return await self.resolver._handle_resolutions(resolutions, uris, page, page_size)
+        except Exception as e:
+            return {'error': str(e)}
 
     async def get_claim_by_claim_id(self, claim_id):
         result = (await self.network.get_claims_by_ids(claim_id)).pop(claim_id, {})
@@ -85,9 +93,10 @@ class MainNetLedger(BaseLedger):
             total_change = len((await account.change.get_addresses()))
             channel_count = await account.get_channel_count()
             claim_count = await account.get_claim_count()
-            log.info("Loaded account %s with %d receiving addresses (gap: %d), "
-                     "%d change addresses (gap: %d), %d channels, %d certificates and %d claims.",
-                     account.id, total_receiving, account.receiving.gap, total_change, account.change.gap,
+            balance = dewies_to_lbc(await account.get_balance())
+            log.info("Loaded account %s with %s LBC, %d receiving addresses (gap: %d), "
+                     "%d change addresses (gap: %d), %d channels, %d certificates and %d claims. ",
+                     account.id, balance, total_receiving, account.receiving.gap, total_change, account.change.gap,
                      channel_count, len(account.certificates), claim_count)
 
 
diff --git a/lbrynet/wallet/manager.py b/lbrynet/extras/wallet/manager.py
similarity index 87%
rename from lbrynet/wallet/manager.py
rename to lbrynet/extras/wallet/manager.py
index 1c73991b4..da57fa614 100644
--- a/lbrynet/wallet/manager.py
+++ b/lbrynet/extras/wallet/manager.py
@@ -9,16 +9,16 @@ from typing import Optional
 
 from twisted.internet import defer
 
-from lbryschema.schema import SECP256k1
-from torba.basemanager import BaseWalletManager
+from lbrynet.schema.schema import SECP256k1
+from torba.client.basemanager import BaseWalletManager
 
-from lbryschema.claim import ClaimDict
+from lbrynet.schema.claim import ClaimDict
 
-from .ledger import MainNetLedger
-from .account import BaseAccount, generate_certificate
-from .transaction import Transaction
-from .database import WalletDatabase
-from .dewies import dewies_to_lbc
+from lbrynet.extras.wallet.ledger import MainNetLedger
+from lbrynet.extras.wallet.account import BaseAccount, generate_certificate
+from lbrynet.extras.wallet.transaction import Transaction
+from lbrynet.extras.wallet.database import WalletDatabase
+from lbrynet.extras.wallet.dewies import dewies_to_lbc
 
 
 log = logging.getLogger(__name__)
@@ -137,8 +137,8 @@ class LbryWalletManager(BaseWalletManager):
                 'certificates': unmigrated.get('claim_certificates', {}),
                 'address_generator': {
                     'name': 'deterministic-chain',
-                    'receiving': {'gap': 20, 'maximum_uses_per_address': 2},
-                    'change': {'gap': 6, 'maximum_uses_per_address': 2}
+                    'receiving': {'gap': 20, 'maximum_uses_per_address': 1},
+                    'change': {'gap': 6, 'maximum_uses_per_address': 1}
                 }
             }]
         }, indent=4, sort_keys=True)
@@ -202,8 +202,10 @@ class LbryWalletManager(BaseWalletManager):
         return manager
 
     async def _migrate_addresses(self, receiving_addresses: set, change_addresses: set):
-        migrated_receiving = set((await self.default_account.receiving.generate_keys(0, len(receiving_addresses))))
-        migrated_change = set((await self.default_account.change.generate_keys(0, len(change_addresses))))
+        async with self.default_account.receiving.address_generator_lock:
+            migrated_receiving = set((await self.default_account.receiving._generate_keys(0, len(receiving_addresses))))
+        async with self.default_account.change.address_generator_lock:
+            migrated_change = set((await self.default_account.change._generate_keys(0, len(change_addresses))))
         receiving_addresses = set(map(self.default_account.ledger.public_key_to_address, receiving_addresses))
         change_addresses = set(map(self.default_account.ledger.public_key_to_address, change_addresses))
         if not any(change_addresses.difference(migrated_change)):
@@ -239,11 +241,16 @@ class LbryWalletManager(BaseWalletManager):
     async def send_claim_to_address(self, claim_id: str, destination_address: str, amount: Optional[int],
                               account=None):
         account = account or self.default_account
-        claims = await account.ledger.db.get_utxos(claim_id=claim_id)
+        claims = await account.get_claims(
+            claim_name_type__any={'is_claim': 1, 'is_update': 1},  # exclude is_supports
+            claim_id=claim_id
+        )
         if not claims:
             raise NameError(f"Claim not found: {claim_id}")
+        if not amount:
+            amount = claims[0].get_estimator(self.ledger).effective_amount
         tx = await Transaction.update(
-            claims[0], ClaimDict.deserialize(claims[0].script.value['claim']), amount,
+            claims[0], ClaimDict.deserialize(claims[0].script.values['claim']), amount,
             destination_address.encode(), [account], account
         )
         await self.ledger.broadcast(tx)
@@ -265,9 +272,10 @@ class LbryWalletManager(BaseWalletManager):
         check_cache = kwargs.get('check_cache', False)  # TODO: put caching back (was force_refresh parameter)
         ledger: MainNetLedger = self.default_account.ledger
         results = await ledger.resolve(page, page_size, *uris)
-        await self.old_db.save_claims_for_resolve(
-            (value for value in results.values() if 'error' not in value)
-        ).asFuture(asyncio.get_event_loop())
+        if 'error' not in results:
+            await self.old_db.save_claims_for_resolve(
+                (value for value in results.values() if 'error' not in value)
+            ).asFuture(asyncio.get_event_loop())
         return results
 
     def get_claims_for_name(self, name: str):
@@ -296,40 +304,60 @@ class LbryWalletManager(BaseWalletManager):
                 'fee': dewies_to_lbc(tx.fee),
                 'date': datetime.fromtimestamp(ts).isoformat(' ')[:-3] if tx.height > 0 else None,
                 'confirmations': headers.height - tx.height if tx.height > 0 else 0,
-                'claim_info': [{
-                    'address': txo.get_address(account.ledger),
-                    'balance_delta': dewies_to_lbc(-txo.amount),
-                    'amount': dewies_to_lbc(txo.amount),
-                    'claim_id': txo.claim_id,
-                    'claim_name': txo.claim_name,
-                    'nout': txo.position
-                } for txo in tx.my_claim_outputs],
-                'update_info': [{
-                    'address': txo.get_address(account.ledger),
-                    'balance_delta': dewies_to_lbc(-txo.amount),
-                    'amount': dewies_to_lbc(txo.amount),
-                    'claim_id': txo.claim_id,
-                    'claim_name': txo.claim_name,
-                    'nout': txo.position
-                } for txo in tx.my_update_outputs],
-                'support_info': [{
-                    'address': txo.get_address(account.ledger),
-                    'balance_delta': dewies_to_lbc(txo.amount),
-                    'amount': dewies_to_lbc(txo.amount),
-                    'claim_id': txo.claim_id,
-                    'claim_name': txo.claim_name,
-                    'is_tip': not txo.is_my_account,
-                    'nout': txo.position
-                } for txo in tx.my_support_outputs],
-                'abandon_info': [{
-                    'address': txo.get_address(account.ledger),
-                    'balance_delta': dewies_to_lbc(-txo.amount),
-                    'amount': dewies_to_lbc(txo.amount),
-                    'claim_id': txo.claim_id,
-                    'claim_name': txo.claim_name,
-                    'nout': txo.position
-                } for txo in tx.my_abandon_outputs],
+                'claim_info': [],
+                'update_info': [],
+                'support_info': [],
+                'abandon_info': []
             }
+            for txo in tx.my_claim_outputs:
+                item['claim_info'].append({
+                    'address': txo.get_address(account.ledger),
+                    'balance_delta': dewies_to_lbc(-txo.amount),
+                    'amount': dewies_to_lbc(txo.amount),
+                    'claim_id': txo.claim_id,
+                    'claim_name': txo.claim_name,
+                    'nout': txo.position
+                })
+            for txo in tx.my_update_outputs:
+                item['update_info'].append({
+                    'address': txo.get_address(account.ledger),
+                    'balance_delta': dewies_to_lbc(-txo.amount),
+                    'amount': dewies_to_lbc(txo.amount),
+                    'claim_id': txo.claim_id,
+                    'claim_name': txo.claim_name,
+                    'nout': txo.position
+                })
+            for txo in tx.my_support_outputs:
+                is_tip = next(tx.my_inputs, None) is None
+                item['support_info'].append({
+                    'address': txo.get_address(account.ledger),
+                    'balance_delta': dewies_to_lbc(txo.amount if is_tip else -txo.amount),
+                    'amount': dewies_to_lbc(txo.amount),
+                    'claim_id': txo.claim_id,
+                    'claim_name': txo.claim_name,
+                    'is_tip': is_tip,
+                    'nout': txo.position
+                })
+            for txo in tx.other_support_outputs:
+                is_tip = next(tx.my_inputs, None) is not None
+                item['support_info'].append({
+                    'address': txo.get_address(account.ledger),
+                    'balance_delta': dewies_to_lbc(-txo.amount),
+                    'amount': dewies_to_lbc(txo.amount),
+                    'claim_id': txo.claim_id,
+                    'claim_name': txo.claim_name,
+                    'is_tip': is_tip,
+                    'nout': txo.position
+                })
+            for txo in tx.my_abandon_outputs:
+                item['abandon_info'].append({
+                    'address': txo.get_address(account.ledger),
+                    'balance_delta': dewies_to_lbc(-txo.amount),
+                    'amount': dewies_to_lbc(txo.amount),
+                    'claim_id': txo.claim_id,
+                    'claim_name': txo.claim_name,
+                    'nout': txo.position
+                })
             if all([txi.txo_ref.txo is not None for txi in tx.inputs]):
                 item['fee'] = dewies_to_lbc(tx.fee)
             else:
@@ -349,7 +377,10 @@ class LbryWalletManager(BaseWalletManager):
             claim = claim.sign(
                 certificate.private_key, claim_address, certificate.claim_id, curve=SECP256k1
             )
-        existing_claims = await account.get_claims(claim_name=name)
+        existing_claims = await account.get_claims(
+            claim_name_type__any={'is_claim': 1, 'is_update': 1},  # exclude is_supports
+            claim_name=name
+        )
         if len(existing_claims) == 0:
             tx = await Transaction.claim(
                 name, claim, amount, claim_address, [account], account
@@ -367,19 +398,6 @@ class LbryWalletManager(BaseWalletManager):
         # TODO: release reserved tx outputs in case anything fails by this point
         return tx
 
-    def _old_get_temp_claim_info(self, tx, txo, address, claim_dict, name, bid):
-        return {
-            "claim_id": txo.claim_id,
-            "name": name,
-            "amount": bid,
-            "address": address,
-            "txid": tx.id,
-            "nout": txo.position,
-            "value": claim_dict,
-            "height": -1,
-            "claim_sequence": -1,
-        }
-
     async def support_claim(self, claim_name, claim_id, amount, account):
         holding_address = await account.receiving.get_or_create_usable_address()
         tx = await Transaction.support(claim_name, claim_id, amount, holding_address, [account], account)
@@ -413,6 +431,19 @@ class LbryWalletManager(BaseWalletManager):
         # TODO: release reserved tx outputs in case anything fails by this point
         return tx
 
+    def _old_get_temp_claim_info(self, tx, txo, address, claim_dict, name, bid):
+        return {
+            "claim_id": txo.claim_id,
+            "name": name,
+            "amount": bid,
+            "address": address,
+            "txid": tx.id,
+            "nout": txo.position,
+            "value": claim_dict,
+            "height": -1,
+            "claim_sequence": -1,
+        }
+
     def get_certificates(self, private_key_accounts, exclude_without_key=True, **constraints):
         return self.db.get_certificates(
             private_key_accounts=private_key_accounts,
diff --git a/lbrynet/wallet/network.py b/lbrynet/extras/wallet/network.py
similarity index 93%
rename from lbrynet/wallet/network.py
rename to lbrynet/extras/wallet/network.py
index 0eadd2ccc..6d9620f6c 100644
--- a/lbrynet/wallet/network.py
+++ b/lbrynet/extras/wallet/network.py
@@ -1,4 +1,4 @@
-from torba.basenetwork import BaseNetwork
+from torba.client.basenetwork import BaseNetwork
 
 
 class Network(BaseNetwork):
diff --git a/lbrynet/wallet/resolve.py b/lbrynet/extras/wallet/resolve.py
similarity index 89%
rename from lbrynet/wallet/resolve.py
rename to lbrynet/extras/wallet/resolve.py
index 060a9ea58..f996b0451 100644
--- a/lbrynet/wallet/resolve.py
+++ b/lbrynet/extras/wallet/resolve.py
@@ -3,14 +3,13 @@ import logging
 from ecdsa import BadSignatureError
 from binascii import unhexlify, hexlify
 
-from lbrynet.core.Error import UnknownNameError, UnknownClaimID, UnknownURI, UnknownOutpoint
-from lbryschema.address import is_address
-from lbryschema.claim import ClaimDict
-from lbryschema.decode import smart_decode
-from lbryschema.error import DecodeError
-from lbryschema.uri import parse_lbry_uri
-
-from .claim_proofs import verify_proof, InvalidProofError
+from lbrynet.p2p.Error import UnknownNameError, UnknownClaimID, UnknownURI, UnknownOutpoint
+from lbrynet.schema.address import is_address
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.schema.decode import smart_decode
+from lbrynet.schema.error import DecodeError
+from lbrynet.schema.uri import parse_lbry_uri
+from lbrynet.extras.wallet.claim_proofs import verify_proof, InvalidProofError
 log = logging.getLogger(__name__)
 
 
@@ -57,14 +56,14 @@ class Resolver:
                                                        height, depth,
                                                        transaction_class=self.transaction_class,
                                                        hash160_to_address=self.hash160_to_address)
-                    result['certificate'] = self.parse_and_validate_claim_result(certificate_result,
-                                                                                 raw=raw)
+                    result['certificate'] = await self.parse_and_validate_claim_result(certificate_result,
+                                                                                       raw=raw)
             elif certificate_resolution_type == "claim_id":
-                result['certificate'] = self.parse_and_validate_claim_result(certificate_response,
-                                                                             raw=raw)
+                result['certificate'] = await self.parse_and_validate_claim_result(certificate_response,
+                                                                                   raw=raw)
             elif certificate_resolution_type == "sequence":
-                result['certificate'] = self.parse_and_validate_claim_result(certificate_response,
-                                                                             raw=raw)
+                result['certificate'] = await self.parse_and_validate_claim_result(certificate_response,
+                                                                                   raw=raw)
             else:
                 log.error("unknown response type: %s", certificate_resolution_type)
 
@@ -97,17 +96,17 @@ class Resolver:
                                                  height, depth,
                                                  transaction_class=self.transaction_class,
                                                  hash160_to_address=self.hash160_to_address)
-                    result['claim'] = self.parse_and_validate_claim_result(claim_result,
-                                                                           certificate,
-                                                                           raw)
+                    result['claim'] = await self.parse_and_validate_claim_result(claim_result,
+                                                                                 certificate,
+                                                                                 raw)
             elif claim_resolution_type == "claim_id":
-                result['claim'] = self.parse_and_validate_claim_result(claim_response,
-                                                                       certificate,
-                                                                       raw)
+                result['claim'] = await self.parse_and_validate_claim_result(claim_response,
+                                                                             certificate,
+                                                                             raw)
             elif claim_resolution_type == "sequence":
-                result['claim'] = self.parse_and_validate_claim_result(claim_response,
-                                                                       certificate,
-                                                                       raw)
+                result['claim'] = await self.parse_and_validate_claim_result(claim_response,
+                                                                             certificate,
+                                                                             raw)
             else:
                 log.error("unknown response type: %s", claim_resolution_type)
 
@@ -137,10 +136,12 @@ class Resolver:
             if claims_in_channel:
                 result['claims_in_channel'] = claims_in_channel
         elif 'error' not in result:
-            result['error'] = "claim not found"
-            result['success'] = False
-            result['uri'] = str(parsed_uri)
+            return {'error': 'claim not found', 'success': False, 'uri': str(parsed_uri)}
 
+        # invalid signatures can only return outside a channel
+        if result.get('claim', {}).get('has_signature', False):
+            if parsed_uri.path and not result['claim']['signature_is_valid']:
+                return {'error': 'claim not found', 'success': False, 'uri': str(parsed_uri)}
         return result
 
     async def get_certificate_and_validate_result(self, claim_result):
@@ -151,9 +152,9 @@ class Resolver:
         if certificate_id:
             certificate = await self.network.get_claims_by_ids(certificate_id.decode())
             certificate = certificate.pop(certificate_id.decode()) if certificate else None
-        return self.parse_and_validate_claim_result(claim_result, certificate=certificate)
+        return await self.parse_and_validate_claim_result(claim_result, certificate=certificate)
 
-    def parse_and_validate_claim_result(self, claim_result, certificate=None, raw=False):
+    async def parse_and_validate_claim_result(self, claim_result, certificate=None, raw=False):
         if not claim_result or 'value' not in claim_result:
             return claim_result
 
@@ -174,7 +175,7 @@ class Resolver:
             if decoded.has_signature:
                 if certificate is None:
                     log.info("fetching certificate to check claim signature")
-                    certificate = self.network.get_claims_by_ids(decoded.certificate_id)
+                    certificate = await self.network.get_claims_by_ids(decoded.certificate_id.decode())
                     if not certificate:
                         log.warning('Certificate %s not found', decoded.certificate_id)
                 claim_result['has_signature'] = True
@@ -235,7 +236,7 @@ class Resolver:
         # these results can include those where `signature_is_valid` is False. if they are skipped,
         # page indexing becomes tricky, as the number of results isn't known until after having
         # processed them.
-        # TODO: fix ^ in lbryschema
+        # TODO: fix ^ in lbrynet.schema
 
         async def iter_validate_channel_claims():
             formatted_claims = []
@@ -244,7 +245,7 @@ class Resolver:
                 for claim_id in claim_ids:
                     claim = batch_result[claim_id]
                     if claim['name'] == claim_names[claim_id]:
-                        formatted_claim = self.parse_and_validate_claim_result(claim, certificate)
+                        formatted_claim = await self.parse_and_validate_claim_result(claim, certificate)
                         formatted_claim['absolute_channel_position'] = claim_positions[
                             claim['claim_id']]
                         formatted_claims.append(formatted_claim)
@@ -384,6 +385,9 @@ def validate_claim_signature_and_get_channel_name(claim, certificate_claim,
                                                   claim_address, decoded_certificate=None):
     if not certificate_claim:
         return False, None
+    if 'value' not in certificate_claim:
+        log.warning('Got an invalid claim while parsing certificates, please report: %s', certificate_claim)
+        return False, None
     certificate = decoded_certificate or smart_decode(certificate_claim['value'])
     if not isinstance(certificate, ClaimDict):
         raise TypeError("Certificate is not a ClaimDict: %s" % str(type(certificate)))
@@ -416,6 +420,12 @@ def _decode_claim_result(claim):
         if not claim['signature_is_valid']:
             log.warning("lbry://%s#%s has an invalid signature",
                         claim['name'], claim['claim_id'])
+    if 'value' not in claim:
+        log.warning('Got an invalid claim while parsing, please report: %s', claim)
+        claim['hex'] = None
+        claim['value'] = None
+        claim['error'] = "Failed to parse: missing value"
+        return claim
     try:
         decoded = smart_decode(claim['value'])
         claim_dict = decoded.claim_dict
diff --git a/lbrynet/wallet/script.py b/lbrynet/extras/wallet/script.py
similarity index 96%
rename from lbrynet/wallet/script.py
rename to lbrynet/extras/wallet/script.py
index 646b089c4..02f1bfda0 100644
--- a/lbrynet/wallet/script.py
+++ b/lbrynet/extras/wallet/script.py
@@ -1,5 +1,5 @@
-from torba.basescript import BaseInputScript, BaseOutputScript, Template
-from torba.basescript import PUSH_SINGLE, PUSH_INTEGER, OP_DROP, OP_2DROP, PUSH_SUBSCRIPT, OP_VERIFY
+from torba.client.basescript import BaseInputScript, BaseOutputScript, Template
+from torba.client.basescript import PUSH_SINGLE, PUSH_INTEGER, OP_DROP, OP_2DROP, PUSH_SUBSCRIPT, OP_VERIFY
 
 
 class InputScript(BaseInputScript):
diff --git a/lbrynet/lbry_file/__init__.py b/lbrynet/extras/wallet/server/__init__.py
similarity index 100%
rename from lbrynet/lbry_file/__init__.py
rename to lbrynet/extras/wallet/server/__init__.py
diff --git a/lbrynet/extras/wallet/server/block_processor.py b/lbrynet/extras/wallet/server/block_processor.py
new file mode 100644
index 000000000..eae699d67
--- /dev/null
+++ b/lbrynet/extras/wallet/server/block_processor.py
@@ -0,0 +1,174 @@
+import hashlib
+import struct
+
+import msgpack
+from torba.server.hash import hash_to_hex_str
+
+from torba.server.block_processor import BlockProcessor
+from lbrynet.schema.proto.claim_pb2 import Claim
+from lbrynet.schema.uri import parse_lbry_uri
+from lbrynet.schema.decode import smart_decode
+
+from lbrynet.extras.wallet.server.model import NameClaim, ClaimInfo, ClaimUpdate, ClaimSupport
+
+
+class LBRYBlockProcessor(BlockProcessor):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.env.coin.NET == "regtest":
+            self.prefetcher.polling_delay = 0.5
+
+        self.should_validate_signatures = self.env.boolean('VALIDATE_CLAIM_SIGNATURES', False)
+        self.logger.info("LbryumX Block Processor - Validating signatures: {}".format(self.should_validate_signatures))
+
+    def advance_blocks(self, blocks):
+        # save height, advance blocks as usual, then hook our claim tx processing
+        height = self.height + 1
+        super().advance_blocks(blocks)
+        pending_undo = []
+        for index, block in enumerate(blocks):
+            undo = self.advance_claim_txs(block.transactions, height + index)
+            pending_undo.append((height+index, undo,))
+        self.db.write_undo(pending_undo)
+
+    def advance_claim_txs(self, txs, height):
+        # TODO: generate claim undo info!
+        undo_info = []
+        add_undo = undo_info.append
+        update_inputs = set()
+        for tx, txid in txs:
+            update_inputs.clear()
+            if tx.has_claims:
+                for index, output in enumerate(tx.outputs):
+                    claim = output.claim
+                    if isinstance(claim, NameClaim):
+                        add_undo(self.advance_claim_name_transaction(output, height, txid, index))
+                    elif isinstance(claim, ClaimUpdate):
+                        update_input = self.db.get_update_input(claim, tx.inputs)
+                        if update_input:
+                            update_inputs.add(update_input)
+                            add_undo(self.advance_update_claim(output, height, txid, index))
+                        else:
+                            info = (hash_to_hex_str(txid), hash_to_hex_str(claim.claim_id),)
+                            self.logger.error("REJECTED: {} updating {}".format(*info))
+                    elif isinstance(claim, ClaimSupport):
+                        self.advance_support(claim, txid, index, height, output.value)
+            for txin in tx.inputs:
+                if txin not in update_inputs:
+                    abandoned_claim_id = self.db.abandon_spent(txin.prev_hash, txin.prev_idx)
+                    if abandoned_claim_id:
+                        add_undo((abandoned_claim_id, self.db.get_claim_info(abandoned_claim_id)))
+        return undo_info
+
+    def advance_update_claim(self, output, height, txid, nout):
+        claim_id = output.claim.claim_id
+        claim_info = self.claim_info_from_output(output, txid, nout, height)
+        old_claim_info = self.db.get_claim_info(claim_id)
+        self.db.put_claim_id_for_outpoint(old_claim_info.txid, old_claim_info.nout, None)
+        if old_claim_info.cert_id:
+            self.db.remove_claim_from_certificate_claims(old_claim_info.cert_id, claim_id)
+        if claim_info.cert_id:
+            self.db.put_claim_id_signed_by_cert_id(claim_info.cert_id, claim_id)
+        self.db.put_claim_info(claim_id, claim_info)
+        self.db.put_claim_id_for_outpoint(txid, nout, claim_id)
+        return claim_id, old_claim_info
+
+    def advance_claim_name_transaction(self, output, height, txid, nout):
+        claim_id = claim_id_hash(txid, nout)
+        claim_info = self.claim_info_from_output(output, txid, nout, height)
+        if claim_info.cert_id:
+            self.db.put_claim_id_signed_by_cert_id(claim_info.cert_id, claim_id)
+        self.db.put_claim_info(claim_id, claim_info)
+        self.db.put_claim_for_name(claim_info.name, claim_id)
+        self.db.put_claim_id_for_outpoint(txid, nout, claim_id)
+        return claim_id, None
+
+    def backup_from_undo_info(self, claim_id, undo_claim_info):
+        """
+        Undo information holds a claim state **before** a transaction changes it
+        There are 4 possibilities when processing it, of which only 3 are valid ones:
+         1. the claim is known and the undo info has info, it was an update
+         2. the claim is known and the undo info doesn't hold any info, it was claimed
+         3. the claim in unknown and the undo info has info, it was abandoned
+         4. the claim is unknown and the undo info does't hold info, error!
+        """
+
+        undo_claim_info = ClaimInfo(*undo_claim_info) if undo_claim_info else None
+        current_claim_info = self.db.get_claim_info(claim_id)
+        if current_claim_info and undo_claim_info:
+            # update, remove current claim
+            self.db.remove_claim_id_for_outpoint(current_claim_info.txid, current_claim_info.nout)
+            if current_claim_info.cert_id:
+                self.db.remove_claim_from_certificate_claims(current_claim_info.cert_id, claim_id)
+        elif current_claim_info and not undo_claim_info:
+            # claim, abandon it
+            self.db.abandon_spent(current_claim_info.txid, current_claim_info.nout)
+        elif not current_claim_info and undo_claim_info:
+            # abandon, reclaim it (happens below)
+            pass
+        else:
+            # should never happen, unless the database got into an inconsistent state
+            raise Exception("Unexpected situation occurred on backup, this means the database is inconsistent. "
+                            "Please report. Resetting the data folder (reindex) solves it for now.")
+        if undo_claim_info:
+            self.db.put_claim_info(claim_id, undo_claim_info)
+            if undo_claim_info.cert_id:
+                cert_id = self._checksig(undo_claim_info.name, undo_claim_info.value, undo_claim_info.address)
+                self.db.put_claim_id_signed_by_cert_id(cert_id, claim_id)
+            self.db.put_claim_for_name(undo_claim_info.name, claim_id)
+            self.db.put_claim_id_for_outpoint(undo_claim_info.txid, undo_claim_info.nout, claim_id)
+
+    def backup_txs(self, txs):
+        self.logger.info("Reorg at height {} with {} transactions.".format(self.height, len(txs)))
+        undo_info = msgpack.loads(self.db.claim_undo_db.get(struct.pack(">I", self.height)), use_list=False)
+        for claim_id, undo_claim_info in reversed(undo_info):
+            self.backup_from_undo_info(claim_id, undo_claim_info)
+        return super().backup_txs(txs)
+
+    def backup_blocks(self, raw_blocks):
+        self.db.batched_flush_claims()
+        super().backup_blocks(raw_blocks=raw_blocks)
+        self.db.batched_flush_claims()
+
+    def shutdown(self):
+        self.db.shutdown()
+
+    async def flush(self, flush_utxos):
+        self.db.batched_flush_claims()
+        return await super().flush(flush_utxos)
+
+    def advance_support(self, claim_support, txid, nout, height, amount):
+        # TODO: check for more controller claim rules, like takeover or ordering
+        pass
+
+    def claim_info_from_output(self, output, txid, nout, height):
+        amount = output.value
+        address = self.coin.address_from_script(output.pk_script)
+        name, value, cert_id = output.claim.name, output.claim.value, None
+        assert txid and address
+        cert_id = self._checksig(name, value, address)
+        return ClaimInfo(name, value, txid, nout, amount, address, height, cert_id)
+
+    def _checksig(self, name, value, address):
+        try:
+            parse_lbry_uri(name.decode())  # skip invalid names
+            cert_id = Claim.FromString(value).publisherSignature.certificateId[::-1] or None
+            if not self.should_validate_signatures:
+                return cert_id
+            if cert_id:
+                cert_claim = self.db.get_claim_info(cert_id)
+                if cert_claim:
+                    certificate = smart_decode(cert_claim.value)
+                    claim_dict = smart_decode(value)
+                    claim_dict.validate_signature(address, certificate)
+                    return cert_id
+        except Exception as e:
+            pass
+
+def claim_id_hash(txid, n):
+    # TODO: This should be in lbryschema
+    packed = txid + struct.pack('>I', n)
+    md = hashlib.new('ripemd160')
+    md.update(hashlib.sha256(packed).digest())
+    return md.digest()
diff --git a/lbrynet/extras/wallet/server/coin.py b/lbrynet/extras/wallet/server/coin.py
new file mode 100644
index 000000000..de5d8ef1e
--- /dev/null
+++ b/lbrynet/extras/wallet/server/coin.py
@@ -0,0 +1,139 @@
+import struct
+
+from torba.server.script import ScriptPubKey, _match_ops, OpCodes
+from torba.server.util import cachedproperty
+from torba.server.hash import hash_to_hex_str, HASHX_LEN
+from hashlib import sha256
+from torba.server.coins import Coin, CoinError
+
+from lbrynet.extras.wallet.server.opcodes import decode_claim_script, opcodes as lbry_opcodes
+
+
+class LBC(Coin):
+    from .session import LBRYElectrumX
+    from .block_processor import LBRYBlockProcessor
+    from .tx import LBRYDeserializer
+    from .daemon import LBCDaemon
+    from .db import LBRYDB
+    DAEMON = LBCDaemon
+    SESSIONCLS = LBRYElectrumX
+    BLOCK_PROCESSOR = LBRYBlockProcessor
+    DB = LBRYDB
+    DESERIALIZER = LBRYDeserializer
+    NAME = "LBRY"
+    SHORTNAME = "LBC"
+    NET = "mainnet"
+    BASIC_HEADER_SIZE = 112
+    CHUNK_SIZE = 96
+    XPUB_VERBYTES = bytes.fromhex("019C354f")
+    XPRV_VERBYTES = bytes.fromhex("019C3118")
+    P2PKH_VERBYTE = bytes.fromhex("55")
+    P2SH_VERBYTES = bytes.fromhex("7A")
+    WIF_BYTE = bytes.fromhex("1C")
+    GENESIS_HASH = ('9c89283ba0f3227f6c03b70216b9f665'
+                    'f0118d5e0fa729cedf4fb34d6a34f463')
+    TX_COUNT = 2716936
+    TX_COUNT_HEIGHT = 329554
+    TX_PER_BLOCK = 1
+    RPC_PORT = 9245
+    REORG_LIMIT = 200
+    PEERS = [
+    ]
+
+    @classmethod
+    def genesis_block(cls, block):
+        '''Check the Genesis block is the right one for this coin.
+
+        Return the block less its unspendable coinbase.
+        '''
+        header = cls.block_header(block, 0)
+        header_hex_hash = hash_to_hex_str(cls.header_hash(header))
+        if header_hex_hash != cls.GENESIS_HASH:
+            raise CoinError('genesis block has hash {} expected {}'
+                            .format(header_hex_hash, cls.GENESIS_HASH))
+
+        return block
+
+    @classmethod
+    def electrum_header(cls, header, height):
+        version, = struct.unpack('<I', header[:4])
+        timestamp, bits, nonce = struct.unpack('<III', header[100:112])
+        return {
+            'version': version,
+            'prev_block_hash': hash_to_hex_str(header[4:36]),
+            'merkle_root': hash_to_hex_str(header[36:68]),
+            'claim_trie_root': hash_to_hex_str(header[68:100]),
+            'timestamp': timestamp,
+            'bits': bits,
+            'nonce': nonce,
+            'block_height': height,
+            }
+
+    @cachedproperty
+    def address_handlers(self):
+        return ScriptPubKey.PayToHandlers(
+            address=self.P2PKH_address_from_hash160,
+            script_hash=self.P2SH_address_from_hash160,
+            pubkey=self.P2PKH_address_from_pubkey,
+            unspendable=lambda: None,
+            strange=self.claim_address_handler,
+        )
+
+    @classmethod
+    def address_from_script(cls, script):
+        '''Given a pk_script, return the adddress it pays to, or None.'''
+        return ScriptPubKey.pay_to(cls.address_handlers, script)
+
+    @classmethod
+    def claim_address_handler(cls, script):
+        '''Parse a claim script, returns the address
+        '''
+        decoded = decode_claim_script(script)
+        if not decoded:
+            return None
+        ops = []
+        for op, data, _ in decoded[1]:
+            if not data:
+                ops.append(op)
+            else:
+                ops.append((op, data,))
+        match = _match_ops
+        TO_ADDRESS_OPS = [OpCodes.OP_DUP, OpCodes.OP_HASH160, -1,
+                          OpCodes.OP_EQUALVERIFY, OpCodes.OP_CHECKSIG]
+        TO_P2SH_OPS = [OpCodes.OP_HASH160, -1, OpCodes.OP_EQUAL]
+        TO_PUBKEY_OPS = [-1, OpCodes.OP_CHECKSIG]
+
+        if match(ops, TO_ADDRESS_OPS):
+            return cls.P2PKH_address_from_hash160(ops[2][-1])
+        if match(ops, TO_P2SH_OPS):
+            return cls.P2SH_address_from_hash160(ops[1][-1])
+        if match(ops, TO_PUBKEY_OPS):
+            return cls.P2PKH_address_from_pubkey(ops[0][-1])
+        if ops and ops[0] == OpCodes.OP_RETURN:
+            return None
+        return None
+
+    @classmethod
+    def hashX_from_script(cls, script):
+        '''
+        Overrides electrumx hashX from script by extracting addresses from claim scripts.
+        '''
+        if script and script[0] == OpCodes.OP_RETURN:
+            return None
+        if script[0] in [
+            lbry_opcodes.OP_CLAIM_NAME,
+            lbry_opcodes.OP_SUPPORT_CLAIM,
+            lbry_opcodes.OP_UPDATE_CLAIM
+        ]:
+            return cls.address_to_hashX(cls.claim_address_handler(script))
+        else:
+            return sha256(script).digest()[:HASHX_LEN]
+
+
+class LBCRegTest(LBC):
+    NET = "regtest"
+    GENESIS_HASH = '6e3fcf1299d4ec5d79c3a4c91d624a4acf9e2e173d95a1a0504f677669687556'
+    XPUB_VERBYTES = bytes.fromhex('043587cf')
+    XPRV_VERBYTES = bytes.fromhex('04358394')
+    P2PKH_VERBYTE = bytes.fromhex("6f")
+    P2SH_VERBYTES = bytes.fromhex("c4")
diff --git a/lbrynet/extras/wallet/server/daemon.py b/lbrynet/extras/wallet/server/daemon.py
new file mode 100644
index 000000000..bdb1ab4df
--- /dev/null
+++ b/lbrynet/extras/wallet/server/daemon.py
@@ -0,0 +1,60 @@
+from aiorpcx import RPCError
+from functools import wraps
+
+from torba.server.daemon import Daemon, DaemonError
+
+
+def handles_errors(decorated_function):
+    @wraps(decorated_function)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await decorated_function(*args, **kwargs)
+        except DaemonError as daemon_error:
+            raise RPCError(1, daemon_error.args[0])
+    return wrapper
+
+
+class LBCDaemon(Daemon):
+    @handles_errors
+    async def getrawtransaction(self, hex_hash, verbose=False):
+        return await super().getrawtransaction(hex_hash=hex_hash, verbose=verbose)
+
+    @handles_errors
+    async def getclaimbyid(self, claim_id):
+        '''Given a claim id, retrieves claim information.'''
+        return await self._send_single('getclaimbyid', (claim_id,))
+
+    @handles_errors
+    async def getclaimsbyids(self, claim_ids):
+        '''Given a list of claim ids, batches calls to retrieve claim information.'''
+        return await self._send_vector('getclaimbyid', ((claim_id,) for claim_id in claim_ids))
+
+    @handles_errors
+    async def getclaimsforname(self, name):
+        '''Given a name, retrieves all claims matching that name.'''
+        return await self._send_single('getclaimsforname', (name,))
+
+    @handles_errors
+    async def getclaimsfortx(self, txid):
+        '''Given a txid, returns the claims it make.'''
+        return await self._send_single('getclaimsfortx', (txid,))
+
+    @handles_errors
+    async def getnameproof(self, name, block_hash=None):
+        '''Given a name and optional block_hash, returns a name proof and winner, if any.'''
+        return await self._send_single('getnameproof', (name, block_hash,) if block_hash else (name,))
+
+    @handles_errors
+    async def getvalueforname(self, name):
+        '''Given a name, returns the winning claim value.'''
+        return await self._send_single('getvalueforname', (name,))
+
+    @handles_errors
+    async def claimname(self, name, hexvalue, amount):
+        '''Claim a name, used for functional tests only.'''
+        return await self._send_single('claimname', (name, hexvalue, float(amount)))
+
+    @handles_errors
+    async def generate(self, number_of_blocks):
+        '''Generates regtest blocks, used for functional tests only.'''
+        return await self._send_single('generate', (int(number_of_blocks),))
diff --git a/lbrynet/extras/wallet/server/db.py b/lbrynet/extras/wallet/server/db.py
new file mode 100644
index 000000000..de2ad15b2
--- /dev/null
+++ b/lbrynet/extras/wallet/server/db.py
@@ -0,0 +1,212 @@
+import msgpack
+import struct
+
+import time
+from torba.server.hash import hash_to_hex_str
+
+from torba.server.db import DB
+
+from lbrynet.extras.wallet.server.model import ClaimInfo
+
+
+class LBRYDB(DB):
+
+    def __init__(self, *args, **kwargs):
+        self.claim_cache = {}
+        self.claims_for_name_cache = {}
+        self.claims_signed_by_cert_cache = {}
+        self.outpoint_to_claim_id_cache = {}
+        self.claims_db = self.names_db = self.signatures_db = self.outpoint_to_claim_id_db = self.claim_undo_db = None
+        # stores deletes not yet flushed to disk
+        self.pending_abandons = {}
+        super().__init__(*args, **kwargs)
+
+    def shutdown(self):
+        self.batched_flush_claims()
+        self.claims_db.close()
+        self.names_db.close()
+        self.signatures_db.close()
+        self.outpoint_to_claim_id_db.close()
+        self.claim_undo_db.close()
+        self.utxo_db.close()
+        # electrumx ones
+        self.utxo_db.close()
+        self.history.close_db()
+
+    async def _open_dbs(self, for_sync, compacting):
+        await super()._open_dbs(for_sync=for_sync, compacting=compacting)
+        def log_reason(message, is_for_sync):
+            reason = 'sync' if is_for_sync else 'serving'
+            self.logger.info('{} for {}'.format(message, reason))
+
+        if self.claims_db:
+            if self.claims_db.for_sync == for_sync:
+                return
+            log_reason('closing claim DBs to re-open', for_sync)
+            self.claims_db.close()
+            self.names_db.close()
+            self.signatures_db.close()
+            self.outpoint_to_claim_id_db.close()
+            self.claim_undo_db.close()
+        self.claims_db = self.db_class('claims', for_sync)
+        self.names_db = self.db_class('names', for_sync)
+        self.signatures_db = self.db_class('signatures', for_sync)
+        self.outpoint_to_claim_id_db = self.db_class('outpoint_claim_id', for_sync)
+        self.claim_undo_db = self.db_class('claim_undo', for_sync)
+        log_reason('opened claim DBs', self.claims_db.for_sync)
+
+    def flush_dbs(self, flush_data, flush_utxos, estimate_txs_remaining):
+        # flush claims together with utxos as they are parsed together
+        self.batched_flush_claims()
+        return super().flush_dbs(flush_data, flush_utxos, estimate_txs_remaining)
+
+    def batched_flush_claims(self):
+        with self.claims_db.write_batch() as claims_batch:
+            with self.names_db.write_batch() as names_batch:
+                with self.signatures_db.write_batch() as signed_claims_batch:
+                    with self.outpoint_to_claim_id_db.write_batch() as outpoint_batch:
+                        self.flush_claims(claims_batch, names_batch, signed_claims_batch,
+                                          outpoint_batch)
+
+    def flush_claims(self, batch, names_batch, signed_claims_batch, outpoint_batch):
+        flush_start = time.time()
+        write_claim, write_name, write_cert = batch.put, names_batch.put, signed_claims_batch.put
+        write_outpoint = outpoint_batch.put
+        delete_claim, delete_outpoint, delete_name = batch.delete, outpoint_batch.delete, names_batch.delete
+        delete_cert = signed_claims_batch.delete
+        for claim_id, outpoints in self.pending_abandons.items():
+            claim = self.get_claim_info(claim_id)
+            self.remove_claim_for_name(claim.name, claim_id)
+            if claim.cert_id:
+                self.remove_claim_from_certificate_claims(claim.cert_id, claim_id)
+            self.remove_certificate(claim_id)
+            self.claim_cache[claim_id] = None
+            for txid, tx_index in outpoints:
+                self.put_claim_id_for_outpoint(txid, tx_index, None)
+        for key, claim in self.claim_cache.items():
+            if claim:
+                write_claim(key, claim)
+            else:
+                delete_claim(key)
+        for name, claims in self.claims_for_name_cache.items():
+            if not claims:
+                delete_name(name)
+            else:
+                write_name(name, msgpack.dumps(claims))
+        for cert_id, claims in self.claims_signed_by_cert_cache.items():
+            if not claims:
+                delete_cert(cert_id)
+            else:
+                write_cert(cert_id, msgpack.dumps(claims))
+        for key, claim_id in self.outpoint_to_claim_id_cache.items():
+            if claim_id:
+                write_outpoint(key, claim_id)
+            else:
+                delete_outpoint(key)
+        self.logger.info('flushed at height {:,d} with {:,d} claims, {:,d} outpoints, {:,d} names '
+                         'and {:,d} certificates added while {:,d} were abandoned in {:.1f}s, committing...'
+                         .format(self.db_height,
+                                 len(self.claim_cache), len(self.outpoint_to_claim_id_cache),
+                                 len(self.claims_for_name_cache),
+                                 len(self.claims_signed_by_cert_cache), len(self.pending_abandons),
+                                 time.time() - flush_start))
+        self.claim_cache = {}
+        self.claims_for_name_cache = {}
+        self.claims_signed_by_cert_cache = {}
+        self.outpoint_to_claim_id_cache = {}
+        self.pending_abandons = {}
+
+    def assert_flushed(self, flush_data):
+        super().assert_flushed(flush_data)
+        assert not self.claim_cache
+        assert not self.claims_for_name_cache
+        assert not self.claims_signed_by_cert_cache
+        assert not self.outpoint_to_claim_id_cache
+        assert not self.pending_abandons
+
+    def abandon_spent(self, tx_hash, tx_idx):
+        claim_id = self.get_claim_id_from_outpoint(tx_hash, tx_idx)
+        if claim_id:
+            self.logger.info("[!] Abandon: {}".format(hash_to_hex_str(claim_id)))
+            self.pending_abandons.setdefault(claim_id, []).append((tx_hash, tx_idx,))
+            return claim_id
+
+    def put_claim_id_for_outpoint(self, tx_hash, tx_idx, claim_id):
+        self.logger.info("[+] Adding outpoint: {}:{} for {}.".format(hash_to_hex_str(tx_hash), tx_idx,
+                                                                     hash_to_hex_str(claim_id) if claim_id else None))
+        self.outpoint_to_claim_id_cache[tx_hash + struct.pack('>I', tx_idx)] = claim_id
+
+    def remove_claim_id_for_outpoint(self, tx_hash, tx_idx):
+        self.logger.info("[-] Remove outpoint: {}:{}.".format(hash_to_hex_str(tx_hash), tx_idx))
+        self.outpoint_to_claim_id_cache[tx_hash + struct.pack('>I', tx_idx)] = None
+
+    def get_claim_id_from_outpoint(self, tx_hash, tx_idx):
+        key = tx_hash + struct.pack('>I', tx_idx)
+        return self.outpoint_to_claim_id_cache.get(key) or self.outpoint_to_claim_id_db.get(key)
+
+    def get_claims_for_name(self, name):
+        if name in self.claims_for_name_cache:
+            return self.claims_for_name_cache[name]
+        db_claims = self.names_db.get(name)
+        return msgpack.loads(db_claims) if db_claims else {}
+
+    def put_claim_for_name(self, name, claim_id):
+        self.logger.info("[+] Adding claim {} for name {}.".format(hash_to_hex_str(claim_id), name))
+        claims = self.get_claims_for_name(name)
+        claims.setdefault(claim_id, max(claims.values() or [0]) + 1)
+        self.claims_for_name_cache[name] = claims
+
+    def remove_claim_for_name(self, name, claim_id):
+        self.logger.info("[-] Removing claim from name: {} - {}".format(hash_to_hex_str(claim_id), name))
+        claims = self.get_claims_for_name(name)
+        claim_n = claims.pop(claim_id)
+        for _claim_id, number in claims.items():
+            if number > claim_n:
+                claims[_claim_id] = number - 1
+        self.claims_for_name_cache[name] = claims
+
+    def get_signed_claim_ids_by_cert_id(self, cert_id):
+        if cert_id in self.claims_signed_by_cert_cache:
+            return self.claims_signed_by_cert_cache[cert_id]
+        db_claims = self.signatures_db.get(cert_id)
+        return msgpack.loads(db_claims, use_list=True) if db_claims else []
+
+    def put_claim_id_signed_by_cert_id(self, cert_id, claim_id):
+        self.logger.info("[+] Adding signature: {} - {}".format(hash_to_hex_str(claim_id), hash_to_hex_str(cert_id)))
+        certs = self.get_signed_claim_ids_by_cert_id(cert_id)
+        certs.append(claim_id)
+        self.claims_signed_by_cert_cache[cert_id] = certs
+
+    def remove_certificate(self, cert_id):
+        self.logger.info("[-] Removing certificate: {}".format(hash_to_hex_str(cert_id)))
+        self.claims_signed_by_cert_cache[cert_id] = []
+
+    def remove_claim_from_certificate_claims(self, cert_id, claim_id):
+        self.logger.info("[-] Removing signature: {} - {}".format(hash_to_hex_str(claim_id), hash_to_hex_str(cert_id)))
+        certs = self.get_signed_claim_ids_by_cert_id(cert_id)
+        if claim_id in certs:
+            certs.remove(claim_id)
+        self.claims_signed_by_cert_cache[cert_id] = certs
+
+    def get_claim_info(self, claim_id):
+        serialized = self.claim_cache.get(claim_id) or self.claims_db.get(claim_id)
+        return ClaimInfo.from_serialized(serialized) if serialized else None
+
+    def put_claim_info(self, claim_id, claim_info):
+        self.logger.info("[+] Adding claim info for: {}".format(hash_to_hex_str(claim_id)))
+        self.claim_cache[claim_id] = claim_info.serialized
+
+    def get_update_input(self, claim, inputs):
+        claim_id = claim.claim_id
+        claim_info = self.get_claim_info(claim_id)
+        if not claim_info:
+            return False
+        for input in inputs:
+            if input.prev_hash == claim_info.txid and input.prev_idx == claim_info.nout:
+                return input
+        return False
+
+    def write_undo(self, pending_undo):
+        with self.claim_undo_db.write_batch() as writer:
+            for height, undo_info in pending_undo:
+                writer.put(struct.pack(">I", height), msgpack.dumps(undo_info))
diff --git a/lbrynet/extras/wallet/server/model.py b/lbrynet/extras/wallet/server/model.py
new file mode 100644
index 000000000..2f6067266
--- /dev/null
+++ b/lbrynet/extras/wallet/server/model.py
@@ -0,0 +1,47 @@
+from collections import namedtuple
+import msgpack
+from torba.server.util import cachedproperty
+# Classes representing data and their serializers, if any.
+
+
+class ClaimInfo(namedtuple("NameClaim", "name value txid nout amount address height cert_id")):
+    '''Claim information as its stored on database'''
+
+    @classmethod
+    def from_serialized(cls, serialized):
+        return cls(*msgpack.loads(serialized))
+
+    @property
+    def serialized(self):
+        return msgpack.dumps(self)
+
+
+class NameClaim(namedtuple("NameClaim", "name value")):
+    pass
+
+
+class ClaimUpdate(namedtuple("ClaimUpdate", "name claim_id value")):
+    pass
+
+
+class ClaimSupport(namedtuple("ClaimSupport", "name claim_id")):
+    pass
+
+
+class LBRYTx(namedtuple("Tx", "version inputs outputs locktime")):
+    '''Transaction that can contain claim, update or support in its outputs.'''
+
+    @cachedproperty
+    def is_coinbase(self):
+        return self.inputs[0].is_coinbase
+
+    @cachedproperty
+    def has_claims(self):
+        for output in self.outputs:
+            if output.claim:
+                return True
+        return False
+
+
+class TxClaimOutput(namedtuple("TxClaimOutput", "value pk_script claim")):
+    pass
diff --git a/lbrynet/extras/wallet/server/opcodes.py b/lbrynet/extras/wallet/server/opcodes.py
new file mode 100644
index 000000000..8e17f5a25
--- /dev/null
+++ b/lbrynet/extras/wallet/server/opcodes.py
@@ -0,0 +1,126 @@
+import struct
+from torba.server.enum import Enumeration
+from lbrynet.extras.wallet.server.model import NameClaim, ClaimSupport, ClaimUpdate
+# TODO: Take this to lbryschema (it's also on lbryum and lbryum-server)
+
+
+opcodes = Enumeration("Opcodes", [
+    ("OP_0", 0), ("OP_PUSHDATA1", 76), "OP_PUSHDATA2", "OP_PUSHDATA4", "OP_1NEGATE", "OP_RESERVED",
+    "OP_1", "OP_2", "OP_3", "OP_4", "OP_5", "OP_6", "OP_7",
+    "OP_8", "OP_9", "OP_10", "OP_11", "OP_12", "OP_13", "OP_14", "OP_15", "OP_16",
+    "OP_NOP", "OP_VER", "OP_IF", "OP_NOTIF", "OP_VERIF", "OP_VERNOTIF", "OP_ELSE", "OP_ENDIF",
+    "OP_VERIFY",
+    "OP_RETURN", "OP_TOALTSTACK", "OP_FROMALTSTACK", "OP_2DROP", "OP_2DUP", "OP_3DUP", "OP_2OVER",
+    "OP_2ROT", "OP_2SWAP",
+    "OP_IFDUP", "OP_DEPTH", "OP_DROP", "OP_DUP", "OP_NIP", "OP_OVER", "OP_PICK", "OP_ROLL",
+    "OP_ROT",
+    "OP_SWAP", "OP_TUCK", "OP_CAT", "OP_SUBSTR", "OP_LEFT", "OP_RIGHT", "OP_SIZE", "OP_INVERT",
+    "OP_AND",
+    "OP_OR", "OP_XOR", "OP_EQUAL", "OP_EQUALVERIFY", "OP_RESERVED1", "OP_RESERVED2", "OP_1ADD",
+    "OP_1SUB", "OP_2MUL",
+    "OP_2DIV", "OP_NEGATE", "OP_ABS", "OP_NOT", "OP_0NOTEQUAL", "OP_ADD", "OP_SUB", "OP_MUL",
+    "OP_DIV",
+    "OP_MOD", "OP_LSHIFT", "OP_RSHIFT", "OP_BOOLAND", "OP_BOOLOR",
+    "OP_NUMEQUAL", "OP_NUMEQUALVERIFY", "OP_NUMNOTEQUAL", "OP_LESSTHAN",
+    "OP_GREATERTHAN", "OP_LESSTHANOREQUAL", "OP_GREATERTHANOREQUAL", "OP_MIN", "OP_MAX",
+    "OP_WITHIN", "OP_RIPEMD160", "OP_SHA1", "OP_SHA256", "OP_HASH160",
+    "OP_HASH256", "OP_CODESEPARATOR", "OP_CHECKSIG", "OP_CHECKSIGVERIFY", "OP_CHECKMULTISIG",
+    "OP_CHECKMULTISIGVERIFY", "OP_NOP1", "OP_NOP2", "OP_NOP3", "OP_NOP4", "OP_NOP5",
+    "OP_CLAIM_NAME",
+    "OP_SUPPORT_CLAIM", "OP_UPDATE_CLAIM",
+    ("OP_SINGLEBYTE_END", 0xF0),
+    ("OP_DOUBLEBYTE_BEGIN", 0xF000),
+    "OP_PUBKEY", "OP_PUBKEYHASH",
+    ("OP_INVALIDOPCODE", 0xFFFF),
+])
+
+
+def script_GetOp(bytes):
+    i = 0
+    while i < len(bytes):
+        vch = None
+        opcode = bytes[i]
+        i += 1
+        if opcode <= opcodes.OP_PUSHDATA4:
+            nSize = opcode
+            if opcode == opcodes.OP_PUSHDATA1:
+                nSize = bytes[i]
+                i += 1
+            elif opcode == opcodes.OP_PUSHDATA2:
+                (nSize,) = struct.unpack_from('<H', bytes, i)
+                i += 2
+            elif opcode == opcodes.OP_PUSHDATA4:
+                (nSize,) = struct.unpack_from('<I', bytes, i)
+                i += 4
+            if i + nSize > len(bytes):
+                vch = "_INVALID_" + bytes[i:]
+                i = len(bytes)
+            else:
+                vch = bytes[i:i + nSize]
+                i += nSize
+        yield (opcode, vch, i)
+
+
+def decode_claim_script(bytes_script):
+    try:
+        decoded_script = [x for x in script_GetOp(bytes_script)]
+    except Exception as e:
+        print(e)
+        return None
+    if len(decoded_script) <= 6:
+        return False
+    op = 0
+    claim_type = decoded_script[op][0]
+    if claim_type == opcodes.OP_UPDATE_CLAIM:
+        if len(decoded_script) <= 7:
+            return False
+    if claim_type not in [
+        opcodes.OP_CLAIM_NAME,
+        opcodes.OP_SUPPORT_CLAIM,
+        opcodes.OP_UPDATE_CLAIM
+    ]:
+        return False
+    op += 1
+    value = None
+    claim_id = None
+    claim = None
+    if not 0 <= decoded_script[op][0] <= opcodes.OP_PUSHDATA4:
+        return False
+    name = decoded_script[op][1]
+    op += 1
+    if not 0 <= decoded_script[op][0] <= opcodes.OP_PUSHDATA4:
+        return False
+    if decoded_script[0][0] in [
+        opcodes.OP_SUPPORT_CLAIM,
+        opcodes.OP_UPDATE_CLAIM
+    ]:
+        claim_id = decoded_script[op][1]
+        if len(claim_id) != 20:
+            return False
+    else:
+        value = decoded_script[op][1]
+    op += 1
+    if decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
+        value = decoded_script[op][1]
+        op += 1
+    if decoded_script[op][0] != opcodes.OP_2DROP:
+        return False
+    op += 1
+    if decoded_script[op][0] != opcodes.OP_DROP and decoded_script[0][0] == opcodes.OP_CLAIM_NAME:
+        return False
+    elif decoded_script[op][0] != opcodes.OP_2DROP and decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
+        return False
+    op += 1
+    if decoded_script[0][0] == opcodes.OP_CLAIM_NAME:
+        if name is None or value is None:
+            return False
+        claim = NameClaim(name, value)
+    elif decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
+        if name is None or value is None or claim_id is None:
+            return False
+        claim = ClaimUpdate(name, claim_id, value)
+    elif decoded_script[0][0] == opcodes.OP_SUPPORT_CLAIM:
+        if name is None or claim_id is None:
+            return False
+        claim = ClaimSupport(name, claim_id)
+    return claim, decoded_script[op:]
diff --git a/lbrynet/extras/wallet/server/session.py b/lbrynet/extras/wallet/server/session.py
new file mode 100644
index 000000000..50313da7e
--- /dev/null
+++ b/lbrynet/extras/wallet/server/session.py
@@ -0,0 +1,395 @@
+import math
+from binascii import unhexlify, hexlify
+
+from aiorpcx import RPCError
+from torba.server.hash import hash_to_hex_str
+from torba.server.session import ElectrumX
+from torba.server import util
+
+from lbrynet.schema.uri import parse_lbry_uri
+from lbrynet.schema.error import URIParseError
+from lbrynet.extras.wallet.server.block_processor import LBRYBlockProcessor
+from lbrynet.extras.wallet.server.db import LBRYDB
+
+
+class LBRYElectrumX(ElectrumX):
+    PROTOCOL_MIN = (0, 0)  # temporary, for supporting 0.10 protocol
+    max_errors = math.inf  # don't disconnect people for errors! let them happen...
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # fixme: this is a rebase hack, we need to go through ChainState instead later
+        self.daemon = self.session_mgr.daemon
+        self.bp: LBRYBlockProcessor = self.session_mgr.bp
+        self.db: LBRYDB = self.bp.db
+        # fixme: lbryum specific subscribe
+        self.subscribe_height = False
+
+    def set_request_handlers(self, ptuple):
+        super().set_request_handlers(ptuple)
+        handlers = {
+            'blockchain.transaction.get_height': self.transaction_get_height,
+            'blockchain.claimtrie.getclaimbyid': self.claimtrie_getclaimbyid,
+            'blockchain.claimtrie.getclaimsforname': self.claimtrie_getclaimsforname,
+            'blockchain.claimtrie.getclaimsbyids': self.claimtrie_getclaimsbyids,
+            'blockchain.claimtrie.getvalue': self.claimtrie_getvalue,
+            'blockchain.claimtrie.getnthclaimforname': self.claimtrie_getnthclaimforname,
+            'blockchain.claimtrie.getclaimsintx': self.claimtrie_getclaimsintx,
+            'blockchain.claimtrie.getclaimssignedby': self.claimtrie_getclaimssignedby,
+            'blockchain.claimtrie.getclaimssignedbynthtoname': self.claimtrie_getclaimssignedbynthtoname,
+            'blockchain.claimtrie.getvalueforuri': self.claimtrie_getvalueforuri,
+            'blockchain.claimtrie.getvaluesforuris': self.claimtrie_getvalueforuris,
+            'blockchain.claimtrie.getclaimssignedbyid': self.claimtrie_getclaimssignedbyid,
+            'blockchain.block.get_server_height': self.get_server_height,
+            'blockchain.block.get_block': self.get_block,
+        }
+        # fixme: methods we use but shouldnt be using anymore. To be removed when torba goes out
+        handlers.update({
+            'blockchain.numblocks.subscribe': self.numblocks_subscribe,
+            'blockchain.utxo.get_address': self.utxo_get_address,
+            'blockchain.transaction.broadcast':
+                self.transaction_broadcast_1_0,
+            'blockchain.transaction.get': self.transaction_get,
+        })
+        self.request_handlers.update(handlers)
+
+    async def utxo_get_address(self, tx_hash, index):
+        # fixme: lbryum
+        # Used only for electrum client command-line requests.  We no
+        # longer index by address, so need to request the raw
+        # transaction.  So it works for any TXO not just UTXOs.
+        self.assert_tx_hash(tx_hash)
+        try:
+            index = int(index)
+            if index < 0:
+                raise ValueError
+        except ValueError:
+            raise RPCError(1, "index has to be >= 0 and integer")
+        raw_tx = await self.daemon_request('getrawtransaction', tx_hash)
+        if not raw_tx:
+            return None
+        raw_tx = util.hex_to_bytes(raw_tx)
+        tx = self.coin.DESERIALIZER(raw_tx).read_tx()
+        if index >= len(tx.outputs):
+            return None
+        return self.coin.address_from_script(tx.outputs[index].pk_script)
+
+    async def transaction_broadcast_1_0(self, raw_tx):
+        # fixme: lbryum
+        # An ugly API: current Electrum clients only pass the raw
+        # transaction in hex and expect error messages to be returned in
+        # the result field.  And the server shouldn't be doing the client's
+        # user interface job here.
+        try:
+            return await self.transaction_broadcast(raw_tx)
+        except RPCError as e:
+            return e.message
+
+    async def numblocks_subscribe(self):
+        # fixme workaround for lbryum
+        '''Subscribe to get height of new blocks.'''
+        self.subscribe_height = True
+        return self.bp.height
+
+    async def notify(self, height, touched):
+        # fixme workaround for lbryum
+        await super().notify(height, touched)
+        if self.subscribe_height and height != self.notified_height:
+            self.send_notification('blockchain.numblocks.subscribe', (height,))
+
+    async def transaction_get(self, tx_hash, verbose=False):
+        # fixme: workaround for lbryum sending the height instead of True/False.
+        # fixme: lbryum_server ignored that and always used False, but this is out of spec
+        if verbose not in (True, False):
+            verbose = False
+        return await self.daemon_request('getrawtransaction', tx_hash, verbose)
+
+    async def get_block(self, block_hash):
+        return await self.daemon.deserialised_block(block_hash)
+
+    async def get_server_height(self):
+        return self.bp.height
+
+    async def transaction_get_height(self, tx_hash):
+        self.assert_tx_hash(tx_hash)
+        transaction_info = await self.daemon.getrawtransaction(tx_hash, True)
+        if transaction_info and 'hex' in transaction_info and 'confirmations' in transaction_info:
+            # an unconfirmed transaction from lbrycrdd will not have a 'confirmations' field
+            height = self.db.db_height
+            height = height - transaction_info['confirmations']
+            return height
+        elif transaction_info and 'hex' in transaction_info:
+            return -1
+        return None
+
+    async def claimtrie_getclaimssignedby(self, name):
+        winning_claim = await self.daemon.getvalueforname(name)
+        if winning_claim:
+            return await self.claimtrie_getclaimssignedbyid(winning_claim['claimId'])
+
+    async def claimtrie_getclaimssignedbyid(self, certificate_id):
+        claim_ids = self.get_claim_ids_signed_by(certificate_id)
+        return await self.batched_formatted_claims_from_daemon(claim_ids)
+
+    def get_claim_ids_signed_by(self, certificate_id):
+        raw_certificate_id = unhexlify(certificate_id)[::-1]
+        raw_claim_ids = self.db.get_signed_claim_ids_by_cert_id(raw_certificate_id)
+        return list(map(hash_to_hex_str, raw_claim_ids))
+
+    def get_signed_claims_with_name_for_channel(self, channel_id, name):
+        claim_ids_for_name = list(self.db.get_claims_for_name(name.encode('ISO-8859-1')).keys())
+        claim_ids_for_name = set(map(hash_to_hex_str, claim_ids_for_name))
+        channel_claim_ids = set(self.get_claim_ids_signed_by(channel_id))
+        return claim_ids_for_name.intersection(channel_claim_ids)
+
+    async def claimtrie_getclaimssignedbynthtoname(self, name, n):
+        n = int(n)
+        for claim_id, sequence in self.db.get_claims_for_name(name.encode('ISO-8859-1')).items():
+            if n == sequence:
+                return await self.claimtrie_getclaimssignedbyid(hash_to_hex_str(claim_id))
+
+    async def claimtrie_getclaimsintx(self, txid):
+        # TODO: this needs further discussion.
+        # Code on lbryum-server is wrong and we need to gather what we clearly expect from this command
+        claim_ids = [claim['claimId'] for claim in (await self.daemon.getclaimsfortx(txid)) if 'claimId' in claim]
+        return await self.batched_formatted_claims_from_daemon(claim_ids)
+
+    async def claimtrie_getvalue(self, name, block_hash=None):
+        proof = await self.daemon.getnameproof(name, block_hash)
+        result = {'proof': proof, 'supports': []}
+
+        if proof_has_winning_claim(proof):
+            tx_hash, nout = proof['txhash'], int(proof['nOut'])
+            transaction_info = await self.daemon.getrawtransaction(tx_hash, True)
+            result['transaction'] = transaction_info['hex']
+            result['height'] = (self.db.db_height - transaction_info['confirmations']) + 1
+            raw_claim_id = self.db.get_claim_id_from_outpoint(unhexlify(tx_hash)[::-1], nout)
+            sequence = self.db.get_claims_for_name(name.encode('ISO-8859-1')).get(raw_claim_id)
+            if sequence:
+                claim_id = hexlify(raw_claim_id[::-1]).decode()
+                claim_info = await self.daemon.getclaimbyid(claim_id)
+                if not claim_info or not claim_info.get('value'):
+                    claim_info = await self.slow_get_claim_by_id_using_name(claim_id)
+                result['claim_sequence'] = sequence
+                result['claim_id'] = claim_id
+                supports = self.format_supports_from_daemon(claim_info.get('supports', []))  # fixme: lbrycrd#124
+                result['supports'] = supports
+            else:
+                self.logger.warning('tx has no claims in db: %s %s', tx_hash, nout)
+        return result
+
+    async def claimtrie_getnthclaimforname(self, name, n):
+        n = int(n)
+        for claim_id, sequence in self.db.get_claims_for_name(name.encode('ISO-8859-1')).items():
+            if n == sequence:
+                return await self.claimtrie_getclaimbyid(hash_to_hex_str(claim_id))
+
+    async def claimtrie_getclaimsforname(self, name):
+        claims = await self.daemon.getclaimsforname(name)
+        if claims:
+            claims['claims'] = [self.format_claim_from_daemon(claim, name) for claim in claims['claims']]
+            claims['supports_without_claims'] = claims['supports without claims']
+            del claims['supports without claims']
+            claims['last_takeover_height'] = claims['nLastTakeoverHeight']
+            del claims['nLastTakeoverHeight']
+            return claims
+        return {}
+
+    async def batched_formatted_claims_from_daemon(self, claim_ids):
+        claims = await self.daemon.getclaimsbyids(claim_ids)
+        result = []
+        for claim, claim_id in zip(claims, claim_ids):
+            if claim and claim.get('value'):
+                result.append(self.format_claim_from_daemon(claim))
+            else:
+                recovered_claim = await self.slow_get_claim_by_id_using_name(claim_id)
+                if recovered_claim:
+                    result.append(self.format_claim_from_daemon(recovered_claim))
+        return result
+
+    def format_claim_from_daemon(self, claim, name=None):
+        '''Changes the returned claim data to the format expected by lbrynet and adds missing fields.'''
+        if not claim:
+            return {}
+        name = name or claim['name']
+        claim_id = claim['claimId']
+        raw_claim_id = unhexlify(claim_id)[::-1]
+        if not self.db.get_claim_info(raw_claim_id):
+            #raise RPCError("Lbrycrd has {} but not lbryumx, please submit a bug report.".format(claim_id))
+            return {}
+        address = self.db.get_claim_info(raw_claim_id).address.decode()
+        sequence = self.db.get_claims_for_name(name.encode('ISO-8859-1')).get(raw_claim_id)
+        if not sequence:
+            return {}
+        supports = self.format_supports_from_daemon(claim.get('supports', []))  # fixme: lbrycrd#124
+
+        amount = get_from_possible_keys(claim, 'amount', 'nAmount')
+        height = get_from_possible_keys(claim, 'height', 'nHeight')
+        effective_amount = get_from_possible_keys(claim, 'effective amount', 'nEffectiveAmount')
+        valid_at_height = get_from_possible_keys(claim, 'valid at height', 'nValidAtHeight')
+
+        return {
+            "name": name,
+            "claim_id": claim['claimId'],
+            "txid": claim['txid'],
+            "nout": claim['n'],
+            "amount": amount,
+            "depth": self.db.db_height - height,
+            "height": height,
+            "value": hexlify(claim['value'].encode('ISO-8859-1')).decode(),
+            "claim_sequence": sequence,  # from index
+            "address": address,  # from index
+            "supports": supports, # fixme: to be included in lbrycrd#124
+            "effective_amount": effective_amount,
+            "valid_at_height": valid_at_height  # TODO PR lbrycrd to include it
+        }
+
+    def format_supports_from_daemon(self, supports):
+        return [[support['txid'], support['n'], get_from_possible_keys(support, 'amount', 'nAmount')] for
+                 support in supports]
+
+    async def claimtrie_getclaimbyid(self, claim_id):
+        self.assert_claim_id(claim_id)
+        claim = await self.daemon.getclaimbyid(claim_id)
+        if not claim or not claim.get('value'):
+            claim = await self.slow_get_claim_by_id_using_name(claim_id)
+        return self.format_claim_from_daemon(claim)
+
+    async def claimtrie_getclaimsbyids(self, *claim_ids):
+        claims = await self.batched_formatted_claims_from_daemon(claim_ids)
+        return dict(zip(claim_ids, claims))
+
+    def assert_tx_hash(self, value):
+        '''Raise an RPCError if the value is not a valid transaction
+        hash.'''
+        try:
+            if len(util.hex_to_bytes(value)) == 32:
+                return
+        except Exception:
+            pass
+        raise RPCError(1, f'{value} should be a transaction hash')
+
+    def assert_claim_id(self, value):
+        '''Raise an RPCError if the value is not a valid claim id
+        hash.'''
+        try:
+            if len(util.hex_to_bytes(value)) == 20:
+                return
+        except Exception:
+            pass
+        raise RPCError(1, f'{value} should be a claim id hash')
+
+    async def slow_get_claim_by_id_using_name(self, claim_id):
+        # TODO: temporary workaround for a lbrycrd bug on indexing. Should be removed when it gets stable
+        raw_claim_id = unhexlify(claim_id)[::-1]
+        claim = self.db.get_claim_info(raw_claim_id)
+        if claim:
+            name = claim.name.decode('ISO-8859-1')
+            claims = await self.daemon.getclaimsforname(name)
+            for claim in claims['claims']:
+                if claim['claimId'] == claim_id:
+                    claim['name'] = name
+                    self.logger.warning(
+                        'Recovered a claim missing from lbrycrd index: %s %s', name, claim_id
+                    )
+                    return claim
+
+    async def claimtrie_getvalueforuri(self, block_hash, uri, known_certificates=None):
+        # TODO: this thing is huge, refactor
+        CLAIM_ID = "claim_id"
+        WINNING = "winning"
+        SEQUENCE = "sequence"
+        uri = uri
+        block_hash = block_hash
+        try:
+            parsed_uri = parse_lbry_uri(uri)
+        except URIParseError as err:
+            return {'error': err.message}
+        result = {}
+
+        if parsed_uri.is_channel:
+            certificate = None
+
+            # TODO: this is also done on the else, refactor
+            if parsed_uri.claim_id:
+                certificate_info = await self.claimtrie_getclaimbyid(parsed_uri.claim_id)
+                if certificate_info and certificate_info['name'] == parsed_uri.name:
+                    certificate = {'resolution_type': CLAIM_ID, 'result': certificate_info}
+            elif parsed_uri.claim_sequence:
+                certificate_info = await self.claimtrie_getnthclaimforname(parsed_uri.name, parsed_uri.claim_sequence)
+                if certificate_info:
+                    certificate = {'resolution_type': SEQUENCE, 'result': certificate_info}
+            else:
+                certificate_info = await self.claimtrie_getvalue(parsed_uri.name, block_hash)
+                if certificate_info:
+                    certificate = {'resolution_type': WINNING, 'result': certificate_info}
+
+            if certificate and 'claim_id' not in certificate['result']:
+                return result
+
+            if certificate and not parsed_uri.path:
+                result['certificate'] = certificate
+                channel_id = certificate['result']['claim_id']
+                claims_in_channel = await self.claimtrie_getclaimssignedbyid(channel_id)
+                result['unverified_claims_in_channel'] = {claim['claim_id']: (claim['name'], claim['height'])
+                                                          for claim in claims_in_channel if claim}
+            elif certificate:
+                result['certificate'] = certificate
+                channel_id = certificate['result']['claim_id']
+                claim_ids_matching_name = self.get_signed_claims_with_name_for_channel(channel_id, parsed_uri.path)
+                claims = await self.batched_formatted_claims_from_daemon(claim_ids_matching_name)
+
+                claims_in_channel = {claim['claim_id']: (claim['name'], claim['height'])
+                                     for claim in claims}
+                result['unverified_claims_for_name'] = claims_in_channel
+        else:
+            claim = None
+            if parsed_uri.claim_id:
+                claim_info = await self.claimtrie_getclaimbyid(parsed_uri.claim_id)
+                if claim_info and claim_info['name'] == parsed_uri.name:
+                    claim = {'resolution_type': CLAIM_ID, 'result': claim_info}
+            elif parsed_uri.claim_sequence:
+                claim_info = await self.claimtrie_getnthclaimforname(parsed_uri.name, parsed_uri.claim_sequence)
+                if claim_info:
+                    claim = {'resolution_type': SEQUENCE, 'result': claim_info}
+            else:
+                claim_info = await self.claimtrie_getvalue(parsed_uri.name, block_hash)
+                if claim_info:
+                    claim = {'resolution_type': WINNING, 'result': claim_info}
+            if (claim and
+                    # is not an unclaimed winning name
+                    (claim['resolution_type'] != WINNING or proof_has_winning_claim(claim['result']['proof']))):
+                raw_claim_id = unhexlify(claim['result']['claim_id'])[::-1]
+                raw_certificate_id = self.db.get_claim_info(raw_claim_id).cert_id
+                if raw_certificate_id:
+                    certificate_id = hash_to_hex_str(raw_certificate_id)
+                    certificate = await self.claimtrie_getclaimbyid(certificate_id)
+                    if certificate:
+                        certificate = {'resolution_type': CLAIM_ID,
+                                       'result': certificate}
+                        result['certificate'] = certificate
+                result['claim'] = claim
+        return result
+
+    async def claimtrie_getvalueforuris(self, block_hash, *uris):
+        MAX_BATCH_URIS = 500
+        if len(uris) > MAX_BATCH_URIS:
+            raise Exception("Exceeds max batch uris of {}".format(MAX_BATCH_URIS))
+
+        return {uri: await self.claimtrie_getvalueforuri(block_hash, uri) for uri in uris}
+
+        # TODO: get it all concurrently when lbrycrd pending changes goes into a stable release
+        #async def getvalue(uri):
+        #    value = await self.claimtrie_getvalueforuri(block_hash, uri)
+        #    return uri, value,
+        #return dict([await asyncio.gather(*tuple(getvalue(uri) for uri in uris))][0])
+
+
+def proof_has_winning_claim(proof):
+    return {'txhash', 'nOut'}.issubset(proof.keys())
+
+
+def get_from_possible_keys(dictionary, *keys):
+    for key in keys:
+        if key in dictionary:
+            return dictionary[key]
diff --git a/lbrynet/extras/wallet/server/tx.py b/lbrynet/extras/wallet/server/tx.py
new file mode 100644
index 000000000..eba24d751
--- /dev/null
+++ b/lbrynet/extras/wallet/server/tx.py
@@ -0,0 +1,21 @@
+from torba.server.tx import Deserializer
+from lbrynet.extras.wallet.server.opcodes import decode_claim_script
+from lbrynet.extras.wallet.server.model import TxClaimOutput, LBRYTx
+
+
+class LBRYDeserializer(Deserializer):
+
+    def _read_output(self):
+        value = self._read_le_int64()
+        script = self._read_varbytes()  # pk_script
+        claim = decode_claim_script(script)
+        claim = claim[0] if claim else None
+        return TxClaimOutput(value, script, claim)
+
+    def read_tx(self):
+        return LBRYTx(
+            self._read_le_int32(),  # version
+            self._read_inputs(),    # inputs
+            self._read_outputs(),   # outputs
+            self._read_le_uint32()  # locktime
+        )
diff --git a/lbrynet/wallet/transaction.py b/lbrynet/extras/wallet/transaction.py
similarity index 90%
rename from lbrynet/wallet/transaction.py
rename to lbrynet/extras/wallet/transaction.py
index 72e27e0ac..fea2fff52 100644
--- a/lbrynet/wallet/transaction.py
+++ b/lbrynet/extras/wallet/transaction.py
@@ -2,13 +2,12 @@ import struct
 from binascii import hexlify, unhexlify
 from typing import List, Iterable, Optional
 
-from lbryschema.decode import smart_decode
-from .account import Account
-from torba.basetransaction import BaseTransaction, BaseInput, BaseOutput
-from torba.hash import hash160
-
-from lbryschema.claim import ClaimDict
-from .script import InputScript, OutputScript
+from torba.client.basetransaction import BaseTransaction, BaseInput, BaseOutput
+from torba.client.hash import hash160
+from lbrynet.schema.decode import smart_decode
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.extras.wallet.account import Account
+from lbrynet.extras.wallet.script import InputScript, OutputScript
 
 
 class Input(BaseInput):
@@ -161,11 +160,22 @@ class Transaction(BaseTransaction):
     def abandon(cls, claims: Iterable[Output], funding_accounts: Iterable[Account], change_account: Account):
         return cls.create([Input.spend(txo) for txo in claims], [], funding_accounts, change_account)
 
+    @property
+    def my_inputs(self):
+        for txi in self.inputs:
+            if txi.txo_ref.txo is not None and txi.txo_ref.txo.is_my_account:
+                yield txi
+
     def _filter_my_outputs(self, f):
         for txo in self.outputs:
             if txo.is_my_account and f(txo.script):
                 yield txo
 
+    def _filter_other_outputs(self, f):
+        for txo in self.outputs:
+            if not txo.is_my_account and f(txo.script):
+                yield txo
+
     @property
     def my_claim_outputs(self):
         return self._filter_my_outputs(lambda s: s.is_claim_name)
@@ -178,6 +188,10 @@ class Transaction(BaseTransaction):
     def my_support_outputs(self):
         return self._filter_my_outputs(lambda s: s.is_support_claim)
 
+    @property
+    def other_support_outputs(self):
+        return self._filter_other_outputs(lambda s: s.is_support_claim)
+
     @property
     def my_abandon_outputs(self):
         for txi in self.inputs:
diff --git a/lbrynet/file_manager/__init__.py b/lbrynet/file_manager/__init__.py
deleted file mode 100644
index e41afc21b..000000000
--- a/lbrynet/file_manager/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""
-Classes and functions used to create and download LBRY Files.
-
-LBRY Files are Crypt Streams created from any regular file. The whole file is read
-at the time that the LBRY File is created, so all constituent blobs are known and
-included in the stream descriptor file.
-"""
diff --git a/lbrynet/interfaces.py b/lbrynet/interfaces.py
deleted file mode 100644
index 5b5e75d13..000000000
--- a/lbrynet/interfaces.py
+++ /dev/null
@@ -1,722 +0,0 @@
-"""
-Interfaces which are implemented by various classes within LBRYnet.
-"""
-from zope.interface import Interface
-
-
-class IPeerFinder(Interface):
-    """
-    Used to find peers by sha384 hashes which they claim to be associated with.
-    """
-    def find_peers_for_blob(self, blob_hash):
-        """
-        Look for peers claiming to be associated with a sha384 hashsum.
-
-        @param blob_hash: The sha384 hashsum to use to look up peers.
-        @type blob_hash: string, hex encoded
-
-        @return: a Deferred object which fires with a list of Peer objects
-        @rtype: Deferred which fires with [Peer]
-        """
-
-
-class IRequestSender(Interface):
-    """
-    Used to connect to a peer, send requests to it, and return the responses to those requests.
-    """
-    def add_request(self, request):
-        """
-        Add a request to the next message that will be sent to the peer
-
-        @param request: a request to be sent to the peer in the next message
-        @type request: ClientRequest
-
-        @return: Deferred object which will callback with the response to this request, a dict
-        @rtype: Deferred which fires with dict
-        """
-
-    def add_blob_request(self, blob_request):
-        """Add a request for a blob to the next message that will be sent to the peer.
-
-        This will cause the protocol to call blob_request.write(data)
-        for all incoming data, after the response message has been
-        parsed out, until blob_request.finished_deferred fires.
-
-        @param blob_request: the request for the blob
-        @type blob_request: ClientBlobRequest
-
-        @return: Deferred object which will callback with the response to this request
-        @rtype: Deferred which fires with dict
-        """
-
-
-class IRequestCreator(Interface):
-    """
-    Send requests, via an IRequestSender, to peers.
-    """
-
-    def send_next_request(self, peer, protocol):
-        """Create a Request object for the peer and then give the protocol that request.
-
-        @param peer: the Peer object which the request will be sent to.
-        @type peer: Peer
-
-        @param protocol: the protocol to pass the request to.
-        @type protocol: object which implements IRequestSender
-
-        @return: Deferred object which will callback with True or
-        False depending on whether a Request was sent
-        @rtype: Deferred which fires with boolean
-        """
-
-    def get_new_peers(self):
-        """
-        Get some new peers which the request creator wants to send requests to.
-
-        @return: Deferred object which will callback with [Peer]
-        @rtype: Deferred which fires with [Peer]
-        """
-
-
-class IMetadataHandler(Interface):
-    """
-    Get metadata for the IDownloadManager.
-    """
-    def get_initial_blobs(self):
-        """Return metadata about blobs that are known to be associated with
-        the stream at the time that the stream is set up.
-
-        @return: Deferred object which will call back with a list of BlobInfo objects
-        @rtype: Deferred which fires with [BlobInfo]
-
-        """
-
-    def final_blob_num(self):
-        """
-        If the last blob in the stream is known, return its blob_num. Otherwise, return None.
-
-        @return: integer representing the final blob num in the stream, or None
-        @rtype: integer or None
-        """
-
-
-class IDownloadManager(Interface):
-    """
-    Manage the downloading of an associated group of blobs, referred to as a stream.
-
-    These objects keep track of metadata about the stream, are responsible for starting and stopping
-    other components, and handle communication between other components.
-    """
-
-    def start_downloading(self):
-        """
-        Load the initial metadata about the stream and then start the other components.
-
-        @return: Deferred which fires when the other components have been started.
-        @rtype: Deferred which fires with boolean
-        """
-
-    def resume_downloading(self):
-        """
-        Start the other components after they have been stopped.
-
-        @return: Deferred which fires when the other components have been started.
-        @rtype: Deferred which fires with boolean
-        """
-
-    def pause_downloading(self):
-        """
-        Stop the other components.
-
-        @return: Deferred which fires when the other components have been stopped.
-        @rtype: Deferred which fires with boolean
-        """
-
-    def add_blobs_to_download(self, blobs):
-        """
-        Add blobs to the list of blobs that should be downloaded
-
-        @param blobs: list of BlobInfos that are associated with the stream being downloaded
-        @type blobs: [BlobInfo]
-
-        @return: DeferredList which fires with the result of adding each previously unknown BlobInfo
-            to the list of known BlobInfos.
-        @rtype: DeferredList which fires with [(boolean, Failure/None)]
-        """
-
-    def stream_position(self):
-        """
-        Returns the blob_num of the next blob needed in the stream.
-
-        If the stream already has all of the blobs it needs, then this will return the blob_num
-        of the last blob in the stream plus 1.
-
-        @return: the blob_num of the next blob needed, or the last blob_num + 1.
-        @rtype: integer
-        """
-
-    def needed_blobs(self):
-        """Returns a list of BlobInfos representing all of the blobs that the
-        stream still needs to download.
-
-        @return: the list of BlobInfos representing blobs that the stream still needs to download.
-        @rtype: [BlobInfo]
-
-        """
-
-    def final_blob_num(self):
-        """
-        If the last blob in the stream is known, return its blob_num. If not, return None.
-
-        @return: The blob_num of the last blob in the stream, or None if it is unknown.
-        @rtype: integer or None
-        """
-
-    def handle_blob(self, blob_num):
-        """This function is called when the next blob in the stream is ready
-        to be handled, whatever that may mean.
-
-        @param blob_num: The blob_num of the blob that is ready to be handled.
-        @type blob_num: integer
-
-        @return: A Deferred which fires when the blob has been 'handled'
-        @rtype: Deferred which can fire with anything
-
-        """
-
-
-class IConnectionManager(Interface):
-    """
-    Connects to peers so that IRequestCreators can send their requests.
-    """
-    def get_next_request(self, peer, protocol):
-        """Ask all IRequestCreators belonging to this object to create a
-        Request for peer and give it to protocol
-
-        @param peer: the peer which the request will be sent to.
-        @type peer: Peer
-
-        @param protocol: the protocol which the request should be sent to by the IRequestCreator.
-        @type protocol: IRequestSender
-
-        @return: Deferred object which will callback with True or
-            False depending on whether the IRequestSender should send
-            the request or hang up
-        @rtype: Deferred which fires with boolean
-
-        """
-
-    def protocol_disconnected(self, peer, protocol):
-        """
-        Inform the IConnectionManager that the protocol has been disconnected
-
-        @param peer: The peer which the connection was to.
-        @type peer: Peer
-
-        @param protocol: The protocol which was disconnected.
-        @type protocol: Protocol
-
-        @return: None
-        """
-
-
-class IProgressManager(Interface):
-    """Responsible for keeping track of the progress of the download.
-
-    Specifically, it is their responsibility to decide which blobs
-    need to be downloaded and keep track of the progress of the
-    download
-
-    """
-    def stream_position(self):
-        """
-        Returns the blob_num of the next blob needed in the stream.
-
-        If the stream already has all of the blobs it needs, then this will return the blob_num
-        of the last blob in the stream plus 1.
-
-        @return: the blob_num of the next blob needed, or the last blob_num + 1.
-        @rtype: integer
-        """
-
-    def needed_blobs(self):
-        """Returns a list of BlobInfos representing all of the blobs that the
-        stream still needs to download.
-
-        @return: the list of BlobInfos representing blobs that the stream still needs to download.
-        @rtype: [BlobInfo]
-
-        """
-
-    def blob_downloaded(self, blob, blob_info):
-        """
-        Mark that a blob has been downloaded and does not need to be downloaded again
-
-        @param blob: the blob that has been downloaded.
-        @type blob: Blob
-
-        @param blob_info: the metadata of the blob that has been downloaded.
-        @type blob_info: BlobInfo
-
-        @return: None
-        """
-
-
-class IBlobHandler(Interface):
-    """
-    Responsible for doing whatever should be done with blobs that have been downloaded.
-    """
-    def blob_downloaded(self, blob, blob_info):
-        """
-        Do whatever the downloader is supposed to do when a blob has been downloaded
-
-        @param blob: The downloaded blob
-        @type blob: Blob
-
-        @param blob_info: The metadata of the downloaded blob
-        @type blob_info: BlobInfo
-
-        @return: A Deferred which fires when the blob has been handled.
-        @rtype: Deferred which can fire with anything
-        """
-
-
-class IRateLimited(Interface):
-    """
-    Have the ability to be throttled (temporarily stopped).
-    """
-    def throttle_upload(self):
-        """
-        Stop uploading data until unthrottle_upload is called.
-
-        @return: None
-        """
-
-    def throttle_download(self):
-        """
-        Stop downloading data until unthrottle_upload is called.
-
-        @return: None
-        """
-
-    def unthrottle_upload(self):
-        """
-        Resume uploading data at will until throttle_upload is called.
-
-        @return: None
-        """
-
-    def unthrottle_downlad(self):
-        """
-        Resume downloading data at will until throttle_download is called.
-
-        @return: None
-        """
-
-
-class IRateLimiter(Interface):
-    """
-    Can keep track of download and upload rates and can throttle objects which implement the
-    IRateLimited interface.
-    """
-    def report_dl_bytes(self, num_bytes):
-        """
-        Inform the IRateLimiter that num_bytes have been downloaded.
-
-        @param num_bytes: the number of bytes that have been downloaded
-        @type num_bytes: integer
-
-        @return: None
-        """
-
-    def report_ul_bytes(self, num_bytes):
-        """
-        Inform the IRateLimiter that num_bytes have been uploaded.
-
-        @param num_bytes: the number of bytes that have been uploaded
-        @type num_bytes: integer
-
-        @return: None
-        """
-
-    def register_protocol(self, protocol):
-        """Register an IRateLimited object with the IRateLimiter so that the
-        IRateLimiter can throttle it
-
-        @param protocol: An object implementing the interface IRateLimited
-        @type protocol: Object implementing IRateLimited
-
-        @return: None
-
-        """
-
-    def unregister_protocol(self, protocol):
-        """Unregister an IRateLimited object so that it won't be throttled any more.
-
-        @param protocol: An object implementing the interface
-            IRateLimited, which was previously registered with this
-            IRateLimiter via "register_protocol"
-        @type protocol: Object implementing IRateLimited
-
-        @return: None
-
-        """
-
-
-class IRequestHandler(Interface):
-    """
-    Pass client queries on to IQueryHandlers
-    """
-    def register_query_handler(self, query_handler, query_identifiers):
-        """Register a query handler, which will be passed any queries that
-        match any of the identifiers in query_identifiers
-
-        @param query_handler: the object which will handle queries
-        matching the given query_identifiers
-        @type query_handler: Object implementing IQueryHandler
-
-        @param query_identifiers: A list of strings representing the query identifiers
-            for queries that should be passed to this handler
-        @type query_identifiers: [string]
-
-        @return: None
-
-        """
-
-    def register_blob_sender(self, blob_sender):
-        """
-        Register a blob sender which will be called after the response has
-        finished to see if it wants to send a blob
-
-        @param blob_sender: the object which will upload the blob to the client.
-        @type blob_sender: IBlobSender
-
-        @return: None
-        """
-
-
-class IBlobSender(Interface):
-    """
-    Upload blobs to clients.
-    """
-    def send_blob_if_requested(self, consumer):
-        """
-        If a blob has been requested, write it to 'write' func of the consumer and then
-        callback the returned deferred when it has all been written
-
-        @param consumer: the object implementing IConsumer which the file will be written to
-        @type consumer: object which implements IConsumer
-
-        @return: Deferred which will fire when the blob sender is done, which will be
-            immediately if no blob should be sent.
-        @rtype: Deferred which fires with anything
-        """
-
-
-class IQueryHandler(Interface):
-    """
-    Respond to requests from clients.
-    """
-    def register_with_request_handler(self, request_handler, peer):
-        """
-        Register with the request handler to receive queries
-
-        @param request_handler: the object implementing IRequestHandler to register with
-        @type request_handler: object implementing IRequestHandler
-
-        @param peer: the Peer which this query handler will be answering requests from
-        @type peer: Peer
-
-        @return: None
-        """
-
-    def handle_queries(self, queries):
-        """
-        Return responses to queries from the client.
-
-        @param queries: a dict representing the query_identifiers:queries that should be handled
-        @type queries: {string: dict}
-
-        @return: a Deferred object which will callback with a dict of query responses
-        @rtype: Deferred which fires with {string: dict}
-        """
-
-
-class IQueryHandlerFactory(Interface):
-    """
-    Construct IQueryHandlers to handle queries from each new client that connects.
-    """
-    def build_query_handler(self):
-        """
-        Create an object that implements the IQueryHandler interface
-
-        @return: object that implements IQueryHandler
-        """
-
-
-class IStreamDownloaderOptions(Interface):
-    def get_downloader_options(self, sd_validator, payment_rate_manager):
-        """
-        Return the list of options that can be used to modify IStreamDownloader behavior
-
-        @param sd_validator: object containing stream metadata, which the options may depend on
-        @type sd_validator: object which implements IStreamDescriptorValidator interface
-
-        @param payment_rate_manager: The payment rate manager currently in effect for the downloader
-        @type payment_rate_manager: PaymentRateManager
-
-        @return: [DownloadOption]
-        @rtype: [DownloadOption]
-        """
-
-
-class IStreamDownloaderFactory(Interface):
-    """Construct IStreamDownloaders and provide options that will be
-    passed to those IStreamDownloaders.
-
-    """
-
-    def can_download(self, sd_validator, payment_rate_manager):
-        """Decide whether the downloaders created by this factory can
-        download the stream described by sd_validator
-
-        @param sd_validator: object containing stream metadata
-        @type sd_validator: object which implements IStreamDescriptorValidator interface
-
-        @param payment_rate_manager: The payment rate manager currently in effect for the downloader
-        @type payment_rate_manager: PaymentRateManager
-
-        @return: True if the downloaders can download the stream, False otherwise
-        @rtype: bool
-
-        """
-
-    def make_downloader(self, sd_validator, options, payment_rate_manager):
-        """Create an object that implements the IStreamDownloader interface
-
-        @param sd_validator: object containing stream metadata which
-            will be given to the IStreamDownloader
-        @type sd_validator: object which implements IStreamDescriptorValidator interface
-
-        @param options: a list of values that will be used by the IStreamDownloaderFactory to
-            construct the IStreamDownloader. the options are in the same order as they were given
-            by get_downloader_options.
-        @type options: [Object]
-
-        @param payment_rate_manager: the PaymentRateManager which the IStreamDownloader should use.
-        @type payment_rate_manager: PaymentRateManager
-
-        @return: a Deferred which fires with the downloader object
-        @rtype: Deferred which fires with IStreamDownloader
-
-        """
-
-    def get_description(self):
-        """
-        Return a string detailing what this downloader does with streams
-
-        @return: short description of what the IStreamDownloader does.
-        @rtype: string
-        """
-
-
-class IStreamDownloader(Interface):
-    """
-    Use metadata and data from the network for some useful purpose.
-    """
-    def start(self):
-        """start downloading the stream
-
-        @return: a Deferred which fires when the stream is finished
-            downloading, or errbacks when the stream is cancelled.
-        @rtype: Deferred which fires with anything
-
-        """
-
-    def insufficient_funds(self, err):
-        """
-        this function informs the stream downloader that funds are too low to finish downloading.
-
-        @return: None
-        """
-
-
-class IStreamDescriptorValidator(Interface):
-    """
-    Pull metadata out of Stream Descriptor Files and perform some
-    validation on the metadata.
-    """
-    def validate(self):
-        """
-        @return: whether the stream descriptor passes validation checks
-        @rtype: boolean
-        """
-
-    def info_to_show(self):
-        """
-
-        @return: A list of tuples representing metadata that should be
-            presented to the user before starting the download
-        @rtype: [(string, string)]
-        """
-
-
-class IWallet(Interface):
-    """Send and receive payments.
-
-    To send a payment, a payment reservation must be obtained
-    first. This guarantees that a payment isn't promised if it can't
-    be paid. When the service in question is rendered, the payment
-    reservation must be given to the IWallet along with the final
-    price. The reservation can also be canceled.
-    """
-    def stop(self):
-        """Send out any unsent payments, close any connections, and stop
-        checking for incoming payments.
-
-        @return: None
-
-        """
-
-    def start(self):
-        """
-        Set up any connections and start checking for incoming payments
-
-        @return: None
-        """
-    def get_info_exchanger(self):
-        """
-        Get the object that will be used to find the payment addresses of peers.
-
-        @return: The object that will be used to find the payment addresses of peers.
-        @rtype: An object implementing IRequestCreator
-        """
-
-    def get_wallet_info_query_handler_factory(self):
-        """
-        Get the object that will be used to give our payment address to peers.
-
-        This must return an object implementing IQueryHandlerFactory. It will be used to
-        create IQueryHandler objects that will be registered with an IRequestHandler.
-
-        @return: The object that will be used to give our payment address to peers.
-        @rtype: An object implementing IQueryHandlerFactory
-        """
-
-    def reserve_points(self, peer, amount):
-        """Ensure a certain amount of points are available to be sent as
-        payment, before the service is rendered
-
-        @param peer: The peer to which the payment will ultimately be sent
-        @type peer: Peer
-
-        @param amount: The amount of points to reserve
-        @type amount: float
-
-        @return: A ReservedPoints object which is given to send_points
-        once the service has been rendered
-        @rtype: ReservedPoints
-
-        """
-
-    def cancel_point_reservation(self, reserved_points):
-        """
-        Return all of the points that were reserved previously for some ReservedPoints object
-
-        @param reserved_points: ReservedPoints previously returned by reserve_points
-        @type reserved_points: ReservedPoints
-
-        @return: None
-        """
-
-    def send_points(self, reserved_points, amount):
-        """
-        Schedule a payment to be sent to a peer
-
-        @param reserved_points: ReservedPoints object previously returned by reserve_points.
-        @type reserved_points: ReservedPoints
-
-        @param amount: amount of points to actually send, must be less than or equal to the
-            amount reserved in reserved_points
-        @type amount: float
-
-        @return: Deferred which fires when the payment has been scheduled
-        @rtype: Deferred which fires with anything
-        """
-
-    def get_balance(self):
-        """
-        Return the balance of this wallet
-
-        @return: Deferred which fires with the balance of the wallet
-        @rtype: Deferred which fires with float
-        """
-
-    def add_expected_payment(self, peer, amount):
-        """
-        Increase the number of points expected to be paid by a peer
-
-        @param peer: the peer which is expected to pay the points
-        @type peer: Peer
-
-        @param amount: the amount of points expected to be paid
-        @type amount: float
-
-        @return: None
-        """
-
-
-class IBlobPriceModel(Interface):
-    """
-    A blob price model
-
-    Used by INegotiationStrategy classes
-    """
-
-    def calculate_price(self, blob):
-        """
-        Calculate the price for a blob
-
-        @param blob: a blob hash
-        @type blob: str
-
-        @return: blob price target
-        @type: Decimal
-        """
-
-
-class INegotiationStrategy(Interface):
-    """
-    Strategy to negotiate download payment rates
-    """
-
-    def make_offer(self, peer, blobs):
-        """
-        Make a rate offer for the given peer and blobs
-
-        @param peer: peer to make an offer to
-        @type: str
-
-        @param blobs: blob hashes to make an offer for
-        @type: list
-
-        @return: rate offer
-        @rtype: Offer
-        """
-
-    def respond_to_offer(self, offer, peer, blobs):
-        """
-        Respond to a rate offer given by a peer
-
-        @param offer: offer to reply to
-        @type: Offer
-
-        @param peer: peer to make an offer to
-        @type: str
-
-        @param blobs: blob hashes to make an offer for
-        @type: list
-
-        @return: accepted, rejected, or unset offer
-        @rtype: Offer
-        """
diff --git a/lbrynet/core/log_support.py b/lbrynet/log_support.py
similarity index 98%
rename from lbrynet/core/log_support.py
rename to lbrynet/log_support.py
index c0c497a6f..2b2803f5b 100644
--- a/lbrynet/core/log_support.py
+++ b/lbrynet/log_support.py
@@ -3,13 +3,11 @@ import logging
 import logging.handlers
 import sys
 import traceback
-
 import treq
-from twisted.internet import defer
 import twisted.python.log
-
-from lbrynet import __version__ as lbrynet_version, build_type, conf
-from lbrynet.core import utils
+from twisted.internet import defer
+from lbrynet import __version__ as lbrynet_version, build_type
+from lbrynet import utils, conf
 
 
 class HTTPSHandler(logging.Handler):
diff --git a/lbrynet/core/BlobAvailability.py b/lbrynet/p2p/BlobAvailability.py
similarity index 99%
rename from lbrynet/core/BlobAvailability.py
rename to lbrynet/p2p/BlobAvailability.py
index 36fb92a27..0ddb7072e 100644
--- a/lbrynet/core/BlobAvailability.py
+++ b/lbrynet/p2p/BlobAvailability.py
@@ -1,10 +1,9 @@
 import logging
 import random
 import time
-
+from decimal import Decimal
 from twisted.internet import defer
 from twisted.internet.task import LoopingCall
-from decimal import Decimal
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/core/BlobInfo.py b/lbrynet/p2p/BlobInfo.py
similarity index 100%
rename from lbrynet/core/BlobInfo.py
rename to lbrynet/p2p/BlobInfo.py
diff --git a/lbrynet/core/BlobManager.py b/lbrynet/p2p/BlobManager.py
similarity index 100%
rename from lbrynet/core/BlobManager.py
rename to lbrynet/p2p/BlobManager.py
diff --git a/lbrynet/core/DownloadOption.py b/lbrynet/p2p/DownloadOption.py
similarity index 100%
rename from lbrynet/core/DownloadOption.py
rename to lbrynet/p2p/DownloadOption.py
diff --git a/lbrynet/core/Error.py b/lbrynet/p2p/Error.py
similarity index 100%
rename from lbrynet/core/Error.py
rename to lbrynet/p2p/Error.py
diff --git a/lbrynet/core/HTTPBlobDownloader.py b/lbrynet/p2p/HTTPBlobDownloader.py
similarity index 98%
rename from lbrynet/core/HTTPBlobDownloader.py
rename to lbrynet/p2p/HTTPBlobDownloader.py
index 9358f3a14..28e6e2a4b 100644
--- a/lbrynet/core/HTTPBlobDownloader.py
+++ b/lbrynet/p2p/HTTPBlobDownloader.py
@@ -1,11 +1,12 @@
-from random import choice
 import logging
+import treq
+from random import choice
 from twisted.internet import defer, task
 from twisted.internet.error import ConnectingCancelledError
 from twisted.web._newclient import ResponseNeverReceived
-import treq
-from lbrynet.core.utils import DeferredDict
-from lbrynet.core.Error import DownloadCanceledError
+
+from lbrynet.utils import DeferredDict
+from lbrynet.p2p.Error import DownloadCanceledError
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/core/Offer.py b/lbrynet/p2p/Offer.py
similarity index 100%
rename from lbrynet/core/Offer.py
rename to lbrynet/p2p/Offer.py
diff --git a/lbrynet/core/PaymentRateManager.py b/lbrynet/p2p/PaymentRateManager.py
similarity index 98%
rename from lbrynet/core/PaymentRateManager.py
rename to lbrynet/p2p/PaymentRateManager.py
index f395e5bfb..7eb8b142c 100644
--- a/lbrynet/core/PaymentRateManager.py
+++ b/lbrynet/p2p/PaymentRateManager.py
@@ -1,6 +1,6 @@
-from lbrynet.core.Strategy import get_default_strategy, OnlyFreeStrategy
-from lbrynet import conf
 from decimal import Decimal
+from lbrynet import conf
+from lbrynet.p2p.Strategy import get_default_strategy, OnlyFreeStrategy
 
 
 class BasePaymentRateManager:
diff --git a/lbrynet/core/Peer.py b/lbrynet/p2p/Peer.py
similarity index 97%
rename from lbrynet/core/Peer.py
rename to lbrynet/p2p/Peer.py
index 9d5bc3a60..bd52e0da3 100644
--- a/lbrynet/core/Peer.py
+++ b/lbrynet/p2p/Peer.py
@@ -1,6 +1,6 @@
 import datetime
 from collections import defaultdict
-from lbrynet.core import utils
+from lbrynet import utils
 
 # Do not create this object except through PeerManager
 class Peer:
diff --git a/lbrynet/core/PriceModel.py b/lbrynet/p2p/PriceModel.py
similarity index 94%
rename from lbrynet/core/PriceModel.py
rename to lbrynet/p2p/PriceModel.py
index 3021566c9..4d065d47a 100644
--- a/lbrynet/core/PriceModel.py
+++ b/lbrynet/p2p/PriceModel.py
@@ -1,7 +1,4 @@
-from zope.interface import implementer
 from decimal import Decimal
-
-from lbrynet.interfaces import IBlobPriceModel
 from lbrynet import conf
 
 
@@ -28,7 +25,6 @@ class MeanAvailabilityWeightedPrice:
         blob_tracker (BlobAvailabilityTracker): blob availability tracker
 
     """
-    implementer(IBlobPriceModel)
 
     def __init__(self, tracker, base_price=None, alpha=1.0):
         self.blob_tracker = tracker
diff --git a/lbrynet/core/RateLimiter.py b/lbrynet/p2p/RateLimiter.py
similarity index 100%
rename from lbrynet/core/RateLimiter.py
rename to lbrynet/p2p/RateLimiter.py
diff --git a/lbrynet/core/SinglePeerDownloader.py b/lbrynet/p2p/SinglePeerDownloader.py
similarity index 86%
rename from lbrynet/core/SinglePeerDownloader.py
rename to lbrynet/p2p/SinglePeerDownloader.py
index e81e0f033..682939427 100644
--- a/lbrynet/core/SinglePeerDownloader.py
+++ b/lbrynet/p2p/SinglePeerDownloader.py
@@ -4,15 +4,15 @@ import tempfile
 
 from twisted.internet import defer, threads, reactor
 
-from lbrynet.blob import BlobFile
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.core.RateLimiter import DummyRateLimiter
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
-from lbrynet.core.client.BlobRequester import BlobRequester
-from lbrynet.core.client.StandaloneBlobDownloader import StandaloneBlobDownloader
-from lbrynet.core.client.ConnectionManager import ConnectionManager
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.dht.peerfinder import DummyPeerFinder
+from lbrynet.blob.blob_file import BlobFile
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.p2p.RateLimiter import DummyRateLimiter
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
+from lbrynet.p2p.client.BlobRequester import BlobRequester
+from lbrynet.p2p.client.StandaloneBlobDownloader import StandaloneBlobDownloader
+from lbrynet.p2p.client.ConnectionManager import ConnectionManager
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.extras.daemon.PeerFinder import DummyPeerFinder
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/core/Strategy.py b/lbrynet/p2p/Strategy.py
similarity index 94%
rename from lbrynet/core/Strategy.py
rename to lbrynet/p2p/Strategy.py
index d8eb62749..da478fb67 100644
--- a/lbrynet/core/Strategy.py
+++ b/lbrynet/p2p/Strategy.py
@@ -1,9 +1,7 @@
-from zope.interface import implementer
 from decimal import Decimal
 from lbrynet import conf
-from lbrynet.interfaces import INegotiationStrategy
-from lbrynet.core.Offer import Offer
-from lbrynet.core.PriceModel import MeanAvailabilityWeightedPrice, ZeroPrice
+from lbrynet.p2p.Offer import Offer
+from lbrynet.p2p.PriceModel import MeanAvailabilityWeightedPrice, ZeroPrice
 
 
 def get_default_strategy(blob_tracker, **kwargs):
@@ -14,7 +12,6 @@ class Strategy:
     """
     Base for negotiation strategies
     """
-    implementer(INegotiationStrategy)
 
     def __init__(self, price_model, max_rate, min_rate, is_generous=None):
         self.price_model = price_model
@@ -100,7 +97,6 @@ class BasicAvailabilityWeightedStrategy(Strategy):
     accepted or a threshold is reached
 
     """
-    implementer(INegotiationStrategy)
 
     def __init__(self, blob_tracker, acceleration=1.25,
                  deceleration=0.9, max_rate=None,
@@ -137,7 +133,6 @@ class BasicAvailabilityWeightedStrategy(Strategy):
 
 
 class OnlyFreeStrategy(Strategy):
-    implementer(INegotiationStrategy)
     def __init__(self, *args, **kwargs):
         price_model = ZeroPrice()
         super().__init__(price_model, 0.0, 0.0, True)
diff --git a/lbrynet/core/StreamDescriptor.py b/lbrynet/p2p/StreamDescriptor.py
similarity index 97%
rename from lbrynet/core/StreamDescriptor.py
rename to lbrynet/p2p/StreamDescriptor.py
index a72a39c31..3b5fddcf1 100644
--- a/lbrynet/core/StreamDescriptor.py
+++ b/lbrynet/p2p/StreamDescriptor.py
@@ -1,14 +1,14 @@
-from binascii import unhexlify
 import string
-from collections import defaultdict
 import json
 import logging
-
+from collections import defaultdict
+from binascii import unhexlify
 from twisted.internet import threads, defer
-from lbrynet.core.cryptoutils import get_lbry_hash_obj
-from lbrynet.core.client.StandaloneBlobDownloader import StandaloneBlobDownloader
-from lbrynet.core.Error import UnknownStreamTypeError, InvalidStreamDescriptorError
-from lbrynet.core.HTTPBlobDownloader import HTTPBlobDownloader
+
+from lbrynet.cryptoutils import get_lbry_hash_obj
+from lbrynet.p2p.client.StandaloneBlobDownloader import StandaloneBlobDownloader
+from lbrynet.p2p.Error import UnknownStreamTypeError, InvalidStreamDescriptorError
+from lbrynet.p2p.HTTPBlobDownloader import HTTPBlobDownloader
 
 log = logging.getLogger(__name__)
 
@@ -29,7 +29,6 @@ class StreamDescriptorReader:
     def _get_raw_data(self):
         """This method must be overridden by subclasses. It should return a deferred
            which fires with the raw data in the stream descriptor"""
-        pass
 
     def get_info(self):
         """Return the fields contained in the file"""
@@ -89,7 +88,6 @@ class StreamDescriptorWriter:
         """This method must be overridden by subclasses to write raw data to
         the stream descriptor
         """
-        pass
 
 
 class PlainStreamDescriptorWriter(StreamDescriptorWriter):
@@ -389,7 +387,7 @@ def validate_descriptor(stream_info):
         raise InvalidStreamDescriptorError("Missing '%s'" % (e.args[0]))
     if stream_info['blobs'][-1]['length'] != 0:
         raise InvalidStreamDescriptorError("Does not end with a zero-length blob.")
-    if any([False if blob_info['length'] > 0 else True for blob_info in stream_info['blobs'][:-1]]):
+    if any([blob_info['length'] == 0 for blob_info in stream_info['blobs'][:-1]]):
         raise InvalidStreamDescriptorError("Contains zero-length data blob")
     if 'blob_hash' in stream_info['blobs'][-1]:
         raise InvalidStreamDescriptorError("Stream terminator blob should not have a hash")
diff --git a/lbrynet/core/__init__.py b/lbrynet/p2p/__init__.py
similarity index 91%
rename from lbrynet/core/__init__.py
rename to lbrynet/p2p/__init__.py
index df7d37558..6ac1f3432 100644
--- a/lbrynet/core/__init__.py
+++ b/lbrynet/p2p/__init__.py
@@ -5,5 +5,3 @@ This includes classes for connecting to other peers and downloading blobs from t
 connections from peers and responding to their requests, managing locally stored blobs, sending
 and receiving payments, and locating peers in the DHT.
 """
-
-from lbrynet import custom_logger
diff --git a/lbrynet/core/client/BlobRequester.py b/lbrynet/p2p/client/BlobRequester.py
similarity index 98%
rename from lbrynet/core/client/BlobRequester.py
rename to lbrynet/p2p/client/BlobRequester.py
index a18849367..d2506043a 100644
--- a/lbrynet/core/client/BlobRequester.py
+++ b/lbrynet/p2p/client/BlobRequester.py
@@ -6,11 +6,11 @@ from twisted.internet import defer
 from twisted.python.failure import Failure
 from twisted.internet.error import ConnectionAborted
 
-from lbrynet.core.Error import ConnectionClosedBeforeResponseError
-from lbrynet.core.Error import InvalidResponseError, RequestCanceledError, NoResponseError
-from lbrynet.core.Error import PriceDisagreementError, DownloadCanceledError, InsufficientFundsError
-from lbrynet.core.client.ClientRequest import ClientRequest, ClientBlobRequest
-from lbrynet.core.Offer import Offer
+from lbrynet.p2p.Error import ConnectionClosedBeforeResponseError
+from lbrynet.p2p.Error import InvalidResponseError, RequestCanceledError, NoResponseError
+from lbrynet.p2p.Error import PriceDisagreementError, DownloadCanceledError, InsufficientFundsError
+from lbrynet.p2p.client.ClientRequest import ClientRequest, ClientBlobRequest
+from lbrynet.p2p.Offer import Offer
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/core/client/ClientProtocol.py b/lbrynet/p2p/client/ClientProtocol.py
similarity index 97%
rename from lbrynet/core/client/ClientProtocol.py
rename to lbrynet/p2p/client/ClientProtocol.py
index dc47a881d..0f8167b79 100644
--- a/lbrynet/core/client/ClientProtocol.py
+++ b/lbrynet/p2p/client/ClientProtocol.py
@@ -5,11 +5,10 @@ from twisted.internet import error, defer
 from twisted.internet.protocol import Protocol, ClientFactory
 from twisted.protocols.policies import TimeoutMixin
 from twisted.python import failure
-from lbrynet import conf
-from lbrynet.core import utils
-from lbrynet.core.Error import ConnectionClosedBeforeResponseError, NoResponseError
-from lbrynet.core.Error import DownloadCanceledError, MisbehavingPeerError
-from lbrynet.core.Error import RequestCanceledError
+from lbrynet import conf, utils
+from lbrynet.p2p.Error import ConnectionClosedBeforeResponseError, NoResponseError
+from lbrynet.p2p.Error import DownloadCanceledError, MisbehavingPeerError
+from lbrynet.p2p.Error import RequestCanceledError
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/core/client/ClientRequest.py b/lbrynet/p2p/client/ClientRequest.py
similarity index 100%
rename from lbrynet/core/client/ClientRequest.py
rename to lbrynet/p2p/client/ClientRequest.py
diff --git a/lbrynet/core/client/ConnectionManager.py b/lbrynet/p2p/client/ConnectionManager.py
similarity index 98%
rename from lbrynet/core/client/ConnectionManager.py
rename to lbrynet/p2p/client/ConnectionManager.py
index f202922a5..af299d167 100644
--- a/lbrynet/core/client/ConnectionManager.py
+++ b/lbrynet/p2p/client/ConnectionManager.py
@@ -1,10 +1,9 @@
 import random
 import logging
 from twisted.internet import defer, reactor
-from lbrynet import conf
-from lbrynet.core.client.ClientProtocol import ClientProtocolFactory
-from lbrynet.core.Error import InsufficientFundsError
-from lbrynet.core import utils
+from lbrynet import utils, conf
+from lbrynet.p2p.client.ClientProtocol import ClientProtocolFactory
+from lbrynet.p2p.Error import InsufficientFundsError
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/core/client/DownloadManager.py b/lbrynet/p2p/client/DownloadManager.py
similarity index 100%
rename from lbrynet/core/client/DownloadManager.py
rename to lbrynet/p2p/client/DownloadManager.py
diff --git a/lbrynet/core/client/StandaloneBlobDownloader.py b/lbrynet/p2p/client/StandaloneBlobDownloader.py
similarity index 92%
rename from lbrynet/core/client/StandaloneBlobDownloader.py
rename to lbrynet/p2p/client/StandaloneBlobDownloader.py
index a0b52ef48..c9434c98c 100644
--- a/lbrynet/core/client/StandaloneBlobDownloader.py
+++ b/lbrynet/p2p/client/StandaloneBlobDownloader.py
@@ -1,10 +1,11 @@
 import logging
-from lbrynet.core.BlobInfo import BlobInfo
-from lbrynet.core.client.BlobRequester import BlobRequester
-from lbrynet.core.client.ConnectionManager import ConnectionManager
-from lbrynet.core.client.DownloadManager import DownloadManager
-from lbrynet.core.Error import InvalidBlobHashError, DownloadSDTimeout
-from lbrynet.core.utils import is_valid_blobhash, safe_start_looping_call, safe_stop_looping_call
+from lbrynet.p2p.BlobInfo import BlobInfo
+from lbrynet.p2p.client.BlobRequester import BlobRequester
+from lbrynet.p2p.client.ConnectionManager import ConnectionManager
+from lbrynet.p2p.client.DownloadManager import DownloadManager
+from lbrynet.p2p.Error import InvalidBlobHashError, DownloadSDTimeout
+from lbrynet.blob.blob_file import is_valid_blobhash
+from lbrynet.utils import safe_start_looping_call, safe_stop_looping_call
 from twisted.python.failure import Failure
 from twisted.internet import defer
 from twisted.internet.task import LoopingCall
diff --git a/lbrynet/core/client/StreamProgressManager.py b/lbrynet/p2p/client/StreamProgressManager.py
similarity index 74%
rename from lbrynet/core/client/StreamProgressManager.py
rename to lbrynet/p2p/client/StreamProgressManager.py
index f7749b666..b1c396d0c 100644
--- a/lbrynet/core/client/StreamProgressManager.py
+++ b/lbrynet/p2p/client/StreamProgressManager.py
@@ -1,15 +1,16 @@
 import logging
-from twisted.internet import defer
+from twisted.internet import defer, task
 
 
 log = logging.getLogger(__name__)
 
 
-class StreamProgressManager:
-    #implements(IProgressManager)
-
-    def __init__(self, finished_callback, blob_manager,
-                 download_manager, delete_blob_after_finished=False):
+class FullStreamProgressManager:
+    def __init__(self, finished_callback, blob_manager, download_manager,
+                 delete_blob_after_finished: bool = False, reactor: task.Clock = None):
+        if not reactor:
+            from twisted.internet import reactor
+        self.reactor = reactor
         self.finished_callback = finished_callback
         self.blob_manager = blob_manager
         self.delete_blob_after_finished = delete_blob_after_finished
@@ -19,15 +20,11 @@ class StreamProgressManager:
         self.stopped = True
         self._next_try_to_output_call = None
         self.outputting_d = None
-
-    ######### IProgressManager #########
+        self.wrote_first_data = defer.Deferred()
 
     def start(self):
-
-        from twisted.internet import reactor
-
         self.stopped = False
-        self._next_try_to_output_call = reactor.callLater(0, self._try_to_output)
+        self._next_try_to_output_call = self.reactor.callLater(0, self._try_to_output)
         return defer.succeed(True)
 
     def stop(self):
@@ -37,64 +34,9 @@ class StreamProgressManager:
         self._next_try_to_output_call = None
         return self._stop_outputting()
 
-    def blob_downloaded(self, blob, blob_num):
-        if self.outputting_d is None:
-            self._output_loop()
-
-    ######### internal #########
-
-    def _finished_outputting(self):
-        self.finished_callback(True)
-
-    def _try_to_output(self):
-
-        from twisted.internet import reactor
-
-        self._next_try_to_output_call = reactor.callLater(1, self._try_to_output)
-        if self.outputting_d is None:
-            self._output_loop()
-
-    def _output_loop(self):
-        pass
-
-    def _stop_outputting(self):
-        if self.outputting_d is not None:
-            return self.outputting_d
-        return defer.succeed(None)
-
-    def _finished_with_blob(self, blob_num):
-        log.debug("In _finished_with_blob, blob_num = %s", str(blob_num))
-        if self.delete_blob_after_finished is True:
-            log.debug("delete_blob_after_finished is True")
-            blobs = self.download_manager.blobs
-            if blob_num in blobs:
-                log.debug("Telling the blob manager, %s, to delete blob %s",
-                          self.blob_manager, blobs[blob_num].blob_hash)
-                self.blob_manager.delete_blobs([blobs[blob_num].blob_hash])
-            else:
-                log.debug("Blob number %s was not in blobs", str(blob_num))
-        else:
-            log.debug("delete_blob_after_finished is False")
-
-
-class FullStreamProgressManager(StreamProgressManager):
-    def __init__(self, finished_callback, blob_manager,
-                 download_manager, delete_blob_after_finished=False):
-        super().__init__(finished_callback, blob_manager, download_manager,
-                         delete_blob_after_finished)
-        self.outputting_d = None
-
-    ######### IProgressManager #########
-
-    def _done(self, i, blobs):
-        """Return true if `i` is a blob number we don't have"""
-        return (
-            i not in blobs or
-            (
-                not blobs[i].get_is_verified() and
-                i not in self.provided_blob_nums
-            )
-        )
+    # def blob_downloaded(self, blob, blob_num):
+    #     if self.outputting_d is None:
+    #         self._output_loop()
 
     def stream_position(self):
         blobs = self.download_manager.blobs
@@ -113,12 +55,46 @@ class FullStreamProgressManager(StreamProgressManager):
             if not b.get_is_verified() and not n in self.provided_blob_nums
         ]
 
-    ######### internal #########
+    def _finished_outputting(self):
+        self.finished_callback(True)
+
+    def _try_to_output(self):
+        self._next_try_to_output_call = self.reactor.callLater(1, self._try_to_output)
+        if self.outputting_d is None:
+            self._output_loop()
+
+    def _stop_outputting(self):
+        if self.outputting_d is not None:
+            return self.outputting_d
+        return defer.succeed(None)
+
+    def _finished_with_blob(self, blob_num: int) -> None:
+        if blob_num == 0 and not self.wrote_first_data.called:
+            self.wrote_first_data.callback(True)
+        log.debug("In _finished_with_blob, blob_num = %s", str(blob_num))
+        if self.delete_blob_after_finished is True:
+            log.debug("delete_blob_after_finished is True")
+            blobs = self.download_manager.blobs
+            if blob_num in blobs:
+                log.debug("Telling the blob manager, %s, to delete blob %s",
+                          self.blob_manager, blobs[blob_num].blob_hash)
+                self.blob_manager.delete_blobs([blobs[blob_num].blob_hash])
+            else:
+                log.debug("Blob number %s was not in blobs", str(blob_num))
+        else:
+            log.debug("delete_blob_after_finished is False")
+
+    def _done(self, i: int, blobs: list) -> bool:
+        """Return true if `i` is a blob number we don't have"""
+        return (
+                i not in blobs or
+                (
+                        not blobs[i].get_is_verified() and
+                        i not in self.provided_blob_nums
+                )
+        )
 
     def _output_loop(self):
-
-        from twisted.internet import reactor
-
         if self.stopped:
             if self.outputting_d is not None:
                 self.outputting_d.callback(True)
@@ -139,7 +115,7 @@ class FullStreamProgressManager(StreamProgressManager):
                 self.outputting_d.callback(True)
                 self.outputting_d = None
             else:
-                reactor.callLater(0, self._output_loop)
+                self.reactor.callLater(0, self._output_loop)
 
         current_blob_num = self.last_blob_outputted + 1
 
diff --git a/lbrynet/lbry_file/client/__init__.py b/lbrynet/p2p/client/__init__.py
similarity index 100%
rename from lbrynet/lbry_file/client/__init__.py
rename to lbrynet/p2p/client/__init__.py
diff --git a/lbrynet/core/server/BlobAvailabilityHandler.py b/lbrynet/p2p/server/BlobAvailabilityHandler.py
similarity index 100%
rename from lbrynet/core/server/BlobAvailabilityHandler.py
rename to lbrynet/p2p/server/BlobAvailabilityHandler.py
diff --git a/lbrynet/core/server/BlobRequestHandler.py b/lbrynet/p2p/server/BlobRequestHandler.py
similarity index 99%
rename from lbrynet/core/server/BlobRequestHandler.py
rename to lbrynet/p2p/server/BlobRequestHandler.py
index 405402c9a..d584c548a 100644
--- a/lbrynet/core/server/BlobRequestHandler.py
+++ b/lbrynet/p2p/server/BlobRequestHandler.py
@@ -4,8 +4,8 @@ from twisted.internet import defer
 from twisted.protocols.basic import FileSender
 from twisted.python.failure import Failure
 
-from lbrynet import analytics
-from lbrynet.core.Offer import Offer
+from lbrynet.extras.daemon import analytics
+from lbrynet.p2p.Offer import Offer
 
 log = logging.getLogger(__name__)
 
diff --git a/lbrynet/core/server/ServerProtocol.py b/lbrynet/p2p/server/ServerProtocol.py
similarity index 97%
rename from lbrynet/core/server/ServerProtocol.py
rename to lbrynet/p2p/server/ServerProtocol.py
index c652c1db1..66c6b4b97 100644
--- a/lbrynet/core/server/ServerProtocol.py
+++ b/lbrynet/p2p/server/ServerProtocol.py
@@ -2,7 +2,7 @@ import logging
 from twisted.internet import error
 from twisted.internet.protocol import Protocol, ServerFactory
 from twisted.python import failure
-from lbrynet.core.server.ServerRequestHandler import ServerRequestHandler
+from lbrynet.p2p.server.ServerRequestHandler import ServerRequestHandler
 
 
 log = logging.getLogger(__name__)
diff --git a/lbrynet/core/server/ServerRequestHandler.py b/lbrynet/p2p/server/ServerRequestHandler.py
similarity index 100%
rename from lbrynet/core/server/ServerRequestHandler.py
rename to lbrynet/p2p/server/ServerRequestHandler.py
diff --git a/lbrynet/reflector/client/__init__.py b/lbrynet/p2p/server/__init__.py
similarity index 100%
rename from lbrynet/reflector/client/__init__.py
rename to lbrynet/p2p/server/__init__.py
diff --git a/lbrynet/schema/Makefile b/lbrynet/schema/Makefile
new file mode 100644
index 000000000..461579cfe
--- /dev/null
+++ b/lbrynet/schema/Makefile
@@ -0,0 +1,6 @@
+build:
+	rm proto/* -rf
+	cd proto && protoc --python_out=. -I ../../../../types/proto/ ../../../../types/proto/*.proto
+	sed -e 's/^import\ \(.*\)_pb2\ /from . import\ \1_pb2\ /g' -i proto/*.py
+	touch proto/__init__.py
+
diff --git a/lbrynet/schema/__init__.py b/lbrynet/schema/__init__.py
new file mode 100644
index 000000000..6c86a5fbb
--- /dev/null
+++ b/lbrynet/schema/__init__.py
@@ -0,0 +1,13 @@
+import os
+
+__version__ = "0.0.16"
+
+BLOCKCHAIN_NAME_ENVVAR = "LBRYSCHEMA_BLOCKCHAIN_NAME"
+if BLOCKCHAIN_NAME_ENVVAR in os.environ:
+    if os.environ[BLOCKCHAIN_NAME_ENVVAR] in ['lbrycrd_main', 'lbrycrd_regtest',
+                                              'lbrycrd_testnet']:
+        BLOCKCHAIN_NAME = os.environ[BLOCKCHAIN_NAME_ENVVAR]
+    else:
+        raise OSError("invalid blockchain name: %s" % os.environ[BLOCKCHAIN_NAME_ENVVAR])
+else:
+    BLOCKCHAIN_NAME = "lbrycrd_main"
diff --git a/lbrynet/schema/address.py b/lbrynet/schema/address.py
new file mode 100644
index 000000000..d6c1c4aac
--- /dev/null
+++ b/lbrynet/schema/address.py
@@ -0,0 +1,64 @@
+import lbrynet.schema
+from lbrynet.schema.base import b58encode, b58decode, validate_b58_checksum
+from lbrynet.schema.hashing import double_sha256, hash160
+from lbrynet.schema.error import InvalidAddress
+from lbrynet.schema.schema import ADDRESS_LENGTH, ADDRESS_PREFIXES, PUBKEY_ADDRESS, SCRIPT_ADDRESS
+
+
+def validate_address_length(addr_bytes):
+    if len(addr_bytes) != ADDRESS_LENGTH:
+        raise InvalidAddress("Invalid address length: %i" % len(addr_bytes))
+
+
+def validate_address_prefix(addr_bytes):
+    prefix = addr_bytes[0]
+    if prefix not in ADDRESS_PREFIXES[lbrynet.schema.BLOCKCHAIN_NAME].values():
+        raise InvalidAddress("Invalid address prefix: %.2X" % prefix)
+
+
+def validate_lbrycrd_address_bytes(addr_bytes):
+    validate_address_length(addr_bytes)
+    validate_address_prefix(addr_bytes)
+    validate_b58_checksum(addr_bytes)
+    return addr_bytes
+
+
+def decode_address(v):
+    """decode and validate a b58 address"""
+    return validate_lbrycrd_address_bytes(b58decode(v))
+
+
+def encode_address(addr_bytes):
+    """validate and encode an address as b58"""
+    v = validate_lbrycrd_address_bytes(addr_bytes)
+    return b58encode(v)
+
+
+def hash_160_bytes_to_address(h160, addrtype=PUBKEY_ADDRESS):
+    if addrtype == PUBKEY_ADDRESS:
+        prefix = chr(ADDRESS_PREFIXES[lbrynet.schema.BLOCKCHAIN_NAME][PUBKEY_ADDRESS])
+    elif addrtype == SCRIPT_ADDRESS:
+        prefix = chr(ADDRESS_PREFIXES[lbrynet.schema.BLOCKCHAIN_NAME][SCRIPT_ADDRESS])
+    else:
+        raise Exception("Invalid address prefix")
+    return b58encode(prefix + h160 + double_sha256(prefix + h160)[0:4])
+
+
+def public_key_to_address(public_key):
+    return hash_160_bytes_to_address(hash160(public_key))
+
+
+def address_to_hash_160(addr):
+    bytes = decode_address(addr)
+    prefix, pubkey_bytes, addr_checksum = bytes[0], bytes[1:21], bytes[21:]
+    if prefix == chr(ADDRESS_PREFIXES[lbrynet.schema.BLOCKCHAIN_NAME][PUBKEY_ADDRESS]):
+        return PUBKEY_ADDRESS, pubkey_bytes
+    return SCRIPT_ADDRESS, pubkey_bytes
+
+
+def is_address(addr):
+    try:
+        addr_bytes = decode_address(addr)
+        return True
+    except InvalidAddress:
+        return False
diff --git a/lbrynet/schema/base.py b/lbrynet/schema/base.py
new file mode 100644
index 000000000..1a87d4e97
--- /dev/null
+++ b/lbrynet/schema/base.py
@@ -0,0 +1,90 @@
+from lbrynet.schema.schema import ADDRESS_CHECKSUM_LENGTH
+from lbrynet.schema.hashing import double_sha256
+from lbrynet.schema.error import InvalidAddress
+
+
+alphabet = b'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+
+def scrub_input(v):
+    if isinstance(v, str) and not isinstance(v, bytes):
+        v = v.encode('ascii')
+    return v
+
+
+def b58encode_int(i, default_one=True):
+    '''Encode an integer using Base58'''
+    if not i and default_one:
+        return alphabet[0:1]
+    string = b""
+    while i:
+        i, idx = divmod(i, 58)
+        string = alphabet[idx:idx+1] + string
+    return string
+
+
+def b58encode(v):
+    '''Encode a string using Base58'''
+
+    v = scrub_input(v)
+
+    nPad = len(v)
+    v = v.lstrip(b'\0')
+    nPad -= len(v)
+
+    p, acc = 1, 0
+    for c in reversed(v):
+        acc += p * c
+        p = p << 8
+
+    result = b58encode_int(acc, default_one=False)
+
+    return alphabet[0:1] * nPad + result
+
+
+def b58decode_int(v):
+    '''Decode a Base58 encoded string as an integer'''
+
+    v = scrub_input(v)
+
+    decimal = 0
+    for char in v:
+        decimal = decimal * 58 + alphabet.index(char)
+    return decimal
+
+
+def b58decode(v):
+    '''Decode a Base58 encoded string'''
+
+    v = scrub_input(v)
+
+    origlen = len(v)
+    v = v.lstrip(alphabet[0:1])
+    newlen = len(v)
+
+    acc = b58decode_int(v)
+
+    result = []
+    while acc > 0:
+        acc, mod = divmod(acc, 256)
+        result.append(mod)
+
+    return b'\0' * (origlen - newlen) + bytes(reversed(result))
+
+
+def validate_b58_checksum(addr_bytes):
+    addr_without_checksum = addr_bytes[:-ADDRESS_CHECKSUM_LENGTH]
+    addr_checksum = addr_bytes[-ADDRESS_CHECKSUM_LENGTH:]
+    if double_sha256(addr_without_checksum)[:ADDRESS_CHECKSUM_LENGTH] != addr_checksum:
+        raise InvalidAddress("Invalid address checksum")
+
+
+def b58decode_strip_checksum(v):
+    addr_bytes = b58decode(v)
+    validate_b58_checksum(addr_bytes)
+    return addr_bytes[:-ADDRESS_CHECKSUM_LENGTH]
+
+
+def b58encode_with_checksum(addr_bytes):
+    addr_checksum = double_sha256(addr_bytes)[:ADDRESS_CHECKSUM_LENGTH]
+    return b58encode(addr_bytes + addr_checksum)
diff --git a/lbrynet/schema/claim.py b/lbrynet/schema/claim.py
new file mode 100644
index 000000000..25215543b
--- /dev/null
+++ b/lbrynet/schema/claim.py
@@ -0,0 +1,193 @@
+import json
+import binascii
+from google.protobuf import json_format  # pylint: disable=no-name-in-module
+from google.protobuf.message import DecodeError as DecodeError_pb  # pylint: disable=no-name-in-module,import-error
+
+from collections import OrderedDict
+
+from lbrynet.schema.schema.claim import Claim
+from lbrynet.schema.proto import claim_pb2
+from lbrynet.schema.validator import get_validator
+from lbrynet.schema.signer import get_signer
+from lbrynet.schema.schema import NIST256p, CURVE_NAMES, CLAIM_TYPE_NAMES
+from lbrynet.schema.encoding import decode_fields, decode_b64_fields, encode_fields
+from lbrynet.schema.error import DecodeError
+from lbrynet.schema.fee import Fee
+
+
+class ClaimDict(OrderedDict):
+    def __init__(self, claim_dict=None):
+        if isinstance(claim_dict, claim_pb2.Claim):
+            raise Exception("To initialize %s with a Claim protobuf use %s.load_protobuf" %
+                            (self.__class__.__name__, self.__class__.__name__))
+        OrderedDict.__init__(self, claim_dict or [])
+
+    @property
+    def protobuf_dict(self):
+        """Claim dictionary using base64 to represent bytes"""
+
+        return json.loads(json_format.MessageToJson(self.protobuf, True))
+
+    @property
+    def protobuf(self):
+        """Claim message object"""
+
+        return Claim.load(self)
+
+    @property
+    def serialized(self):
+        """Serialized Claim protobuf"""
+
+        return self.protobuf.SerializeToString()
+
+    @property
+    def serialized_no_signature(self):
+        """Serialized Claim protobuf without publisherSignature field"""
+        claim = self.protobuf
+        claim.ClearField("publisherSignature")
+        return ClaimDict.load_protobuf(claim).serialized
+
+    @property
+    def has_signature(self):
+        claim = self.protobuf
+        if claim.HasField("publisherSignature"):
+            return True
+        return False
+
+    @property
+    def is_certificate(self):
+        claim = self.protobuf
+        return CLAIM_TYPE_NAMES[claim.claimType] == "certificate"
+
+    @property
+    def is_stream(self):
+        claim = self.protobuf
+        return CLAIM_TYPE_NAMES[claim.claimType] == "stream"
+
+    @property
+    def source_hash(self):
+        claim = self.protobuf
+        if not CLAIM_TYPE_NAMES[claim.claimType] == "stream":
+            return None
+        return binascii.hexlify(claim.stream.source.source)
+
+    @property
+    def has_fee(self):
+        claim = self.protobuf
+        if not CLAIM_TYPE_NAMES[claim.claimType] == "stream":
+            return None
+        if claim.stream.metadata.HasField("fee"):
+            return True
+        return False
+
+    @property
+    def source_fee(self):
+        claim = self.protobuf
+        if not CLAIM_TYPE_NAMES[claim.claimType] == "stream":
+            return None
+        if claim.stream.metadata.HasField("fee"):
+            return Fee.load_protobuf(claim.stream.metadata.fee)
+        return None
+
+    @property
+    def certificate_id(self):
+        if not self.has_signature:
+            return None
+        return binascii.hexlify(self.protobuf.publisherSignature.certificateId)
+
+    @property
+    def signature(self):
+        if not self.has_signature:
+            return None
+        return binascii.hexlify(self.protobuf.publisherSignature.signature)
+
+    @property
+    def protobuf_len(self):
+        """Length of serialized string"""
+
+        return self.protobuf.ByteSize()
+
+    @property
+    def json_len(self):
+        """Length of json encoded string"""
+
+        return len(json.dumps(self.claim_dict))
+
+    @property
+    def claim_dict(self):
+        """Claim dictionary with bytes represented as hex and base58"""
+
+        return dict(encode_fields(self))
+
+    @classmethod
+    def load_protobuf_dict(cls, protobuf_dict):
+        """
+        Load a ClaimDict from a dictionary with base64 encoded bytes
+        (as returned by the protobuf json formatter)
+        """
+
+        return cls(decode_b64_fields(protobuf_dict))
+
+    @classmethod
+    def load_protobuf(cls, protobuf_claim):
+        """Load ClaimDict from a protobuf Claim message"""
+        return cls.load_protobuf_dict(json.loads(json_format.MessageToJson(protobuf_claim, True)))
+
+    @classmethod
+    def load_dict(cls, claim_dict):
+        """Load ClaimDict from a dictionary with hex and base58 encoded bytes"""
+        try:
+            return cls.load_protobuf(cls(decode_fields(claim_dict)).protobuf)
+        except json_format.ParseError as err:
+            raise DecodeError(str(err))
+
+    @classmethod
+    def deserialize(cls, serialized):
+        """Load a ClaimDict from a serialized protobuf string"""
+
+        temp_claim = claim_pb2.Claim()
+        try:
+            temp_claim.ParseFromString(serialized)
+        except DecodeError_pb:
+            raise DecodeError(DecodeError_pb)
+        return cls.load_protobuf(temp_claim)
+
+    @classmethod
+    def generate_certificate(cls, private_key, curve=NIST256p):
+        signer = get_signer(curve).load_pem(private_key)
+        return cls.load_protobuf(signer.certificate)
+
+    def sign(self, private_key, claim_address, cert_claim_id, curve=NIST256p):
+        signer = get_signer(curve).load_pem(private_key)
+        signed = signer.sign_stream_claim(self, claim_address, cert_claim_id)
+        return ClaimDict.load_protobuf(signed)
+
+    def validate_signature(self, claim_address, certificate):
+        if isinstance(certificate, ClaimDict):
+            certificate = certificate.protobuf
+        curve = CURVE_NAMES[certificate.certificate.keyType]
+        validator = get_validator(curve).load_from_certificate(certificate, self.certificate_id)
+        return validator.validate_claim_signature(self, claim_address)
+
+    def validate_private_key(self, private_key, certificate_id):
+        certificate = self.protobuf
+        if CLAIM_TYPE_NAMES[certificate.claimType] != "certificate":
+            return
+        curve = CURVE_NAMES[certificate.certificate.keyType]
+        validator = get_validator(curve).load_from_certificate(certificate, certificate_id)
+        signing_key = validator.signing_key_from_pem(private_key)
+        return validator.validate_private_key(signing_key)
+
+    def get_validator(self, certificate_id):
+        """
+        Get a lbrynet.schema.validator.Validator object for a certificate claim
+
+        :param certificate_id: claim id of this certificate claim
+        :return: None or lbrynet.schema.validator.Validator object
+        """
+
+        claim = self.protobuf
+        if CLAIM_TYPE_NAMES[claim.claimType] != "certificate":
+            return
+        curve = CURVE_NAMES[claim.certificate.keyType]
+        return get_validator(curve).load_from_certificate(claim, certificate_id)
diff --git a/lbrynet/schema/decode.py b/lbrynet/schema/decode.py
new file mode 100644
index 000000000..bb9e31ea2
--- /dev/null
+++ b/lbrynet/schema/decode.py
@@ -0,0 +1,61 @@
+import json
+import binascii
+from google.protobuf import json_format  # pylint: disable=no-name-in-module
+
+from lbrynet.schema.error import DecodeError, InvalidAddress
+from lbrynet.schema.legacy.migrate import migrate as schema_migrator
+from lbrynet.schema.claim import ClaimDict
+
+
+
+def migrate_json_claim_value(decoded_json):
+    try:
+        if 'fee' in decoded_json:
+            old_fee = decoded_json['fee']
+            if not old_fee[list(old_fee.keys())[0]]['amount']:
+                del decoded_json['fee']
+                return migrate_json_claim_value(decoded_json)
+    except (TypeError, AttributeError, InvalidAddress):
+        raise DecodeError("Failed to decode claim")
+    try:
+        pb_migrated = schema_migrator(decoded_json)
+        return pb_migrated
+    except json_format.ParseError as parse_error:
+        raise DecodeError("Failed to parse protobuf: %s" % parse_error)
+    except Exception as err:
+        raise DecodeError("Failed to migrate claim: %s" % err)
+
+
+def smart_decode(claim_value):
+    """
+    Decode a claim value
+
+    Try decoding claim protobuf, if this fails try decoding json and migrating it.
+    If unable to decode or migrate, raise DecodeError
+    """
+
+    # if already decoded, return
+    if isinstance(claim_value, ClaimDict):
+        return claim_value
+    elif isinstance(claim_value, dict):
+        return ClaimDict.load_dict(claim_value)
+
+    try:
+        claim_value = binascii.unhexlify(claim_value)
+    except (TypeError, ValueError):
+        pass
+
+    if claim_value[0] in ['{', ord('{')]:
+        try:
+            if isinstance(claim_value, bytes):
+                claim_value = claim_value.decode()
+            decoded_json = json.loads(claim_value)
+            return migrate_json_claim_value(decoded_json)
+        except (ValueError, TypeError):
+            pass
+    try:
+        if isinstance(claim_value, str):
+            claim_value = claim_value.encode()
+        return ClaimDict.deserialize(claim_value)
+    except (DecodeError, InvalidAddress, KeyError, TypeError):
+        raise DecodeError(claim_value)
diff --git a/lbrynet/schema/encoding.py b/lbrynet/schema/encoding.py
new file mode 100644
index 000000000..9d8aea4a4
--- /dev/null
+++ b/lbrynet/schema/encoding.py
@@ -0,0 +1,78 @@
+import base64, binascii
+from copy import deepcopy
+from lbrynet.schema.address import decode_address, encode_address
+from lbrynet.schema.schema import CLAIM_TYPES, CLAIM_TYPE, STREAM_TYPE, CERTIFICATE_TYPE
+from lbrynet.schema.schema import SIGNATURE
+from lbrynet.schema.error import DecodeError, InvalidAddress
+
+
+def encode_fields(claim_dictionary):
+    """Encode bytes to hex and b58 for return by ClaimDict"""
+    claim_dictionary = deepcopy(claim_dictionary)
+    claim_type = CLAIM_TYPES[claim_dictionary[CLAIM_TYPE]]
+    claim_value = claim_dictionary[claim_type]
+    if claim_type == CLAIM_TYPES[STREAM_TYPE]:
+        claim_value['source']['source'] = binascii.hexlify(claim_value['source']['source']).decode()
+        if 'fee' in claim_value['metadata']:
+            try:
+                address = encode_address(claim_value['metadata']['fee']['address'])
+            except InvalidAddress as err:
+                raise DecodeError("Invalid fee address: %s" % err)
+            claim_value['metadata']['fee']['address'] = address
+    elif claim_type == CLAIM_TYPES[CERTIFICATE_TYPE]:
+        public_key = claim_value["publicKey"]
+        claim_value["publicKey"] = binascii.hexlify(public_key).decode()
+    if SIGNATURE in claim_dictionary:
+        encoded_sig = binascii.hexlify(claim_dictionary[SIGNATURE]['signature']).decode()
+        encoded_cert_id = binascii.hexlify(claim_dictionary[SIGNATURE]['certificateId']).decode()
+        claim_dictionary[SIGNATURE]['signature'] = encoded_sig
+        claim_dictionary[SIGNATURE]['certificateId'] = encoded_cert_id
+    claim_dictionary[claim_type] = claim_value
+    return claim_dictionary
+
+
+def decode_fields(claim_dictionary):
+    """Decode hex and b58 encoded bytes in dictionaries given to ClaimDict"""
+    claim_dictionary = deepcopy(claim_dictionary)
+    claim_type = CLAIM_TYPES[claim_dictionary[CLAIM_TYPE]]
+    claim_value = claim_dictionary[claim_type]
+    if claim_type == CLAIM_TYPES[STREAM_TYPE]:
+        claim_value['source']['source'] = binascii.unhexlify(claim_value['source']['source'])
+        if 'fee' in claim_value['metadata']:
+            try:
+                address = decode_address(claim_value['metadata']['fee']['address'])
+            except InvalidAddress as err:
+                raise DecodeError("Invalid fee address: %s" % err)
+            claim_value['metadata']['fee']['address'] = address
+    elif claim_type == CLAIM_TYPES[CERTIFICATE_TYPE]:
+        public_key = binascii.unhexlify(claim_value["publicKey"])
+        claim_value["publicKey"] = public_key
+    if SIGNATURE in claim_dictionary:
+        decoded_sig = binascii.unhexlify(claim_dictionary[SIGNATURE]['signature'])
+        decoded_cert_id = binascii.unhexlify(claim_dictionary[SIGNATURE]['certificateId'])
+        claim_dictionary[SIGNATURE]['signature'] = decoded_sig
+        claim_dictionary[SIGNATURE]['certificateId'] = decoded_cert_id
+    claim_dictionary[claim_type] = claim_value
+    return claim_dictionary
+
+
+def decode_b64_fields(claim_dictionary):
+    """Decode b64 encoded bytes in protobuf generated dictionary to be given to ClaimDict"""
+    claim_dictionary = deepcopy(claim_dictionary)
+    claim_type = CLAIM_TYPES[claim_dictionary[CLAIM_TYPE]]
+    claim_value = claim_dictionary[claim_type]
+    if claim_type == CLAIM_TYPES[STREAM_TYPE]:
+        claim_value['source']['source'] = base64.b64decode(claim_value['source']['source'])
+        if 'fee' in claim_value['metadata']:
+            address = base64.b64decode(claim_value['metadata']['fee']['address'])
+            claim_value['metadata']['fee']['address'] = address
+    elif claim_type == CLAIM_TYPES[CERTIFICATE_TYPE]:
+        public_key = base64.b64decode(claim_value["publicKey"])
+        claim_value["publicKey"] = public_key
+    if SIGNATURE in claim_dictionary:
+        encoded_sig = base64.b64decode(claim_dictionary[SIGNATURE]['signature'])
+        encoded_cert_id = base64.b64decode(claim_dictionary[SIGNATURE]['certificateId'])
+        claim_dictionary[SIGNATURE]['signature'] = encoded_sig
+        claim_dictionary[SIGNATURE]['certificateId'] = encoded_cert_id
+    claim_dictionary[claim_type] = claim_value
+    return claim_dictionary
diff --git a/lbrynet/schema/error.py b/lbrynet/schema/error.py
new file mode 100644
index 000000000..57d50293a
--- /dev/null
+++ b/lbrynet/schema/error.py
@@ -0,0 +1,22 @@
+class UnknownSourceType(Exception):
+    pass
+
+
+class InvalidSourceHashLength(Exception):
+    pass
+
+
+class DecodeError(Exception):
+    pass
+
+
+class URIParseError(Exception):
+    pass
+
+
+class CertificateError(Exception):
+    pass
+
+
+class InvalidAddress(Exception):
+    pass
diff --git a/lbrynet/schema/fee.py b/lbrynet/schema/fee.py
new file mode 100644
index 000000000..4c3bb3447
--- /dev/null
+++ b/lbrynet/schema/fee.py
@@ -0,0 +1,79 @@
+from collections import OrderedDict
+
+from lbrynet.schema.address import encode_address, decode_address
+from lbrynet.schema.schema import CURRENCY_NAMES, CURRENCY_MAP
+from lbrynet.schema.schema.fee import Fee as FeeHelper
+from lbrynet.schema.proto import fee_pb2
+
+
+def migrate(fee):
+    if len(list(fee.keys())) == 3 and 'currency' in fee and 'amount' in fee and 'address' in fee:
+        return FeeHelper.load({
+            "version": "_0_0_1",
+            "currency": fee['currency'],
+            "amount": fee['amount'],
+            "address": decode_address(fee['address'])
+        })
+    if len(list(fee.keys())) > 1:
+        raise Exception("Invalid fee")
+
+    currency = list(fee.keys())[0]
+    amount = fee[currency]['amount']
+    address = fee[currency]['address']
+
+    return FeeHelper.load({
+        "version": "_0_0_1",
+        "currency": currency,
+        "amount": amount,
+        "address": decode_address(address)
+    })
+
+
+class Fee(OrderedDict):
+    def __init__(self, fee):
+        if (len(fee) == 4 and "version" in fee and "currency" in fee
+           and "amount" in fee and "address" in fee):
+            OrderedDict.__init__(self, fee)
+        else:
+            OrderedDict.__init__(self, Fee.load_protobuf(migrate(fee)))
+
+    @property
+    def currency(self):
+        return self['currency']
+
+    @property
+    def address(self):
+        return self['address']
+
+    @property
+    def amount(self):
+        return self['amount']
+
+    @property
+    def version(self):
+        return self['version']
+
+    @property
+    def protobuf(self):
+        pb = {
+            "version": self.version,
+            "currency": CURRENCY_MAP[self.currency],
+            "address": decode_address(self.address),
+            "amount": self.amount
+        }
+        return FeeHelper.load(pb)
+
+    @classmethod
+    def load_protobuf(cls, pb):
+        return cls({
+                "version": pb.version,
+                "currency": CURRENCY_NAMES[pb.currency],
+                "address": encode_address(pb.address),
+                "amount": pb.amount
+        })
+
+    @classmethod
+    def deserialize(cls, serialized):
+        pb = fee_pb2.Fee()
+        pb.ParseFromString(serialized)
+        return cls.load_protobuf(pb)
diff --git a/lbrynet/schema/hashing.py b/lbrynet/schema/hashing.py
new file mode 100644
index 000000000..ee1a8f16e
--- /dev/null
+++ b/lbrynet/schema/hashing.py
@@ -0,0 +1,23 @@
+import hashlib
+
+
+def sha256(x):
+    if isinstance(x, str):
+        x = x.encode('utf-8')
+    return hashlib.sha256(x).digest()
+
+
+def double_sha256(x):
+    return sha256(sha256(x))
+
+
+def ripemd160(x):
+    if isinstance(x, str):
+        x = x.encode('utf-8')
+    md = hashlib.new('ripemd160')
+    md.update(x)
+    return md.digest()
+
+
+def hash160(x):
+    return ripemd160(sha256(x))
diff --git a/lbrynet/schema/legacy/StructuredDict.py b/lbrynet/schema/legacy/StructuredDict.py
new file mode 100644
index 000000000..31442d0d8
--- /dev/null
+++ b/lbrynet/schema/legacy/StructuredDict.py
@@ -0,0 +1,59 @@
+import jsonschema
+
+
+class StructuredDict(dict):
+    """
+    A dictionary that enforces a structure specified by a schema, and supports
+    migration between different versions of the schema.
+    """
+
+    # To be specified in sub-classes, an array in the format
+    # [(version, schema, migration), ...]
+    _versions = []
+
+    # Used internally to allow schema lookups by version number
+    _schemas = {}
+
+    version = None
+
+    def __init__(self, value, starting_version, migrate=True, target_version=None):
+        dict.__init__(self, value)
+
+        self.version = starting_version
+        self._schemas = dict([(version, schema) for (version, schema, _) in self._versions])
+
+        self.validate(starting_version)
+
+        if migrate:
+            self.migrate(target_version)
+
+    def _upgrade_version_range(self, start_version, end_version):
+        after_starting_version = False
+        for version, schema, migration in self._versions:
+            if not after_starting_version:
+                if version == self.version:
+                    after_starting_version = True
+                continue
+
+            yield version, schema, migration
+
+            if end_version and version == end_version:
+                break
+
+    def validate(self, version):
+        jsonschema.validate(self, self._schemas[version])
+
+    def migrate(self, target_version=None):
+        if target_version:
+            assert self._versions.index(target_version) > self._versions.index(self.version), \
+                "Current version is above target version"
+
+        for version, schema, migration in self._upgrade_version_range(self.version, target_version):
+            migration(self)
+            try:
+                self.validate(version)
+            except jsonschema.ValidationError as e:
+                raise jsonschema.ValidationError(
+                    "Could not migrate to version %s due to validation error: %s" %
+                    (version, e.message))
+            self.version = version
diff --git a/lbrynet/reflector/server/__init__.py b/lbrynet/schema/legacy/__init__.py
similarity index 100%
rename from lbrynet/reflector/server/__init__.py
rename to lbrynet/schema/legacy/__init__.py
diff --git a/lbrynet/schema/legacy/metadata_schemas.py b/lbrynet/schema/legacy/metadata_schemas.py
new file mode 100644
index 000000000..6165ccaa6
--- /dev/null
+++ b/lbrynet/schema/legacy/metadata_schemas.py
@@ -0,0 +1,276 @@
+VER_001 = {
+    '$schema': 'http://json-schema.org/draft-04/schema#',
+    'title': 'LBRY metadata schema 0.0.1',
+    'definitions': {
+        'fee_info': {
+            'type': 'object',
+            'properties': {
+                'amount': {
+                    'type': 'number',
+                    'minimum': 0,
+                    'exclusiveMinimum': True,
+                },
+                'address': {
+                    'type': 'string'
+                }
+            },
+        }
+    },
+    'type': 'object',
+
+    'properties': {
+        'ver': {
+            'type': 'string',
+            'default': '0.0.1'
+        },
+        'title': {
+            'type': 'string'
+        },
+        'description': {
+            'type': 'string'
+        },
+        'author': {
+            'type': 'string'
+        },
+        'language': {
+            'type': 'string'
+        },
+        'license': {
+            'type': 'string'
+        },
+        'content-type': {
+            'type': 'string'
+        },
+        'sources': {
+            'type': 'object',
+            'properties': {
+                'lbry_sd_hash': {
+                    'type': 'string'
+                },
+                'btih': {
+                    'type': 'string'
+                },
+                'url': {
+                    'type': 'string'
+                }
+            },
+            'additionalProperties': False
+        },
+        'thumbnail': {
+            'type': 'string'
+        },
+        'preview': {
+            'type': 'string'
+        },
+        'fee': {
+            'properties': {
+                'LBC': {'$ref': '#/definitions/fee_info'},
+                'BTC': {'$ref': '#/definitions/fee_info'},
+                'USD': {'$ref': '#/definitions/fee_info'}
+            }
+        },
+        'contact': {
+            'type': 'number'
+        },
+        'pubkey': {
+            'type': 'string'
+        },
+    },
+    'required': [
+        'title', 'description', 'author', 'language', 'license', 'content-type', 'sources'],
+    'additionalProperties': False
+}
+
+
+VER_002 = {
+    '$schema': 'http://json-schema.org/draft-04/schema#',
+    'title': 'LBRY metadata schema 0.0.2',
+    'definitions': {
+        'fee_info': {
+            'type': 'object',
+            'properties': {
+                'amount': {
+                    'type': 'number',
+                    'minimum': 0,
+                    'exclusiveMinimum': True,
+                },
+                'address': {
+                    'type': 'string'
+                }
+            },
+        }
+    },
+    'type': 'object',
+
+    'properties': {
+        'ver': {
+            'type': 'string',
+            'enum': ['0.0.2'],
+        },
+        'title': {
+            'type': 'string'
+        },
+        'description': {
+            'type': 'string'
+        },
+        'author': {
+            'type': 'string'
+        },
+        'language': {
+            'type': 'string'
+        },
+        'license': {
+            'type': 'string'
+        },
+        'content-type': {
+            'type': 'string'
+        },
+        'sources': {
+            'type': 'object',
+            'properties': {
+                'lbry_sd_hash': {
+                    'type': 'string'
+                },
+                'btih': {
+                    'type': 'string'
+                },
+                'url': {
+                    'type': 'string'
+                }
+            },
+            'additionalProperties': False
+        },
+        'thumbnail': {
+            'type': 'string'
+        },
+        'preview': {
+            'type': 'string'
+        },
+        'fee': {
+            'properties': {
+                'LBC': {'$ref': '#/definitions/fee_info'},
+                'BTC': {'$ref': '#/definitions/fee_info'},
+                'USD': {'$ref': '#/definitions/fee_info'}
+            }
+        },
+        'contact': {
+            'type': 'number'
+        },
+        'pubkey': {
+            'type': 'string'
+        },
+        'license_url': {
+            'type': 'string'
+        },
+        'nsfw': {
+            'type': 'boolean',
+            'default': False
+        },
+
+    },
+    'required': [
+        'ver', 'title', 'description', 'author', 'language', 'license',
+        'content-type', 'sources', 'nsfw'
+    ],
+    'additionalProperties': False
+}
+
+
+VER_003 = {
+    '$schema': 'http://json-schema.org/draft-04/schema#',
+    'title': 'LBRY metadata schema 0.0.3',
+    'definitions': {
+        'fee_info': {
+            'type': 'object',
+            'properties': {
+                'amount': {
+                    'type': 'number',
+                    'minimum': 0,
+                    'exclusiveMinimum': True,
+                },
+                'address': {
+                    'type': 'string'
+                }
+            },
+        }
+    },
+    'type': 'object',
+
+    'properties': {
+        'ver': {
+            'type': 'string',
+            'enum': ['0.0.3'],
+        },
+        'title': {
+            'type': 'string'
+        },
+        'description': {
+            'type': 'string'
+        },
+        'author': {
+            'type': 'string'
+        },
+        'language': {
+            'type': 'string'
+        },
+        'license': {
+            'type': 'string'
+        },
+        'content_type': {
+            'type': 'string'
+        },
+        'sources': {
+            'type': 'object',
+            'properties': {
+                'lbry_sd_hash': {
+                    'type': 'string'
+                },
+                'btih': {
+                    'type': 'string'
+                },
+                'url': {
+                    'type': 'string'
+                }
+            },
+            'additionalProperties': False
+        },
+        'thumbnail': {
+            'type': 'string'
+        },
+        'preview': {
+            'type': 'string'
+        },
+        'fee': {
+            'properties': {
+                'LBC': {'$ref': '#/definitions/fee_info'},
+                'BTC': {'$ref': '#/definitions/fee_info'},
+                'USD': {'$ref': '#/definitions/fee_info'}
+            }
+        },
+        'contact': {
+            'type': 'number'
+        },
+        'pubkey': {
+            'type': 'string'
+        },
+        'license_url': {
+            'type': 'string'
+        },
+        'nsfw': {
+            'type': 'boolean',
+            'default': False
+        },
+        'sig': {
+            'type': 'string'
+        }
+    },
+    'required': [
+        'ver', 'title', 'description', 'author', 'language', 'license',
+        'content_type', 'sources', 'nsfw'
+    ],
+    'additionalProperties': False,
+    'dependencies': {
+        'pubkey': ['sig'],
+        'sig': ['pubkey']
+    }
+}
diff --git a/lbrynet/schema/legacy/migrate.py b/lbrynet/schema/legacy/migrate.py
new file mode 100644
index 000000000..3b515c5be
--- /dev/null
+++ b/lbrynet/schema/legacy/migrate.py
@@ -0,0 +1,79 @@
+"""
+migrate claim json schema (0.0.1-3) to protobuf (0.1.0)
+"""
+
+from lbrynet.schema.legacy import metadata_schemas
+from lbrynet.schema.claim import ClaimDict
+from .StructuredDict import StructuredDict
+
+
+def migrate_001_to_002(metadata):
+    metadata['ver'] = '0.0.2'
+    metadata['nsfw'] = False
+
+
+def migrate_002_to_003(metadata):
+    metadata['ver'] = '0.0.3'
+    if 'content-type' in metadata:
+        metadata['content_type'] = metadata['content-type']
+        del metadata['content-type']
+
+
+class LegacyMetadata(StructuredDict):
+    current_version = '0.0.3'
+
+    _versions = [
+        ('0.0.1', metadata_schemas.VER_001, None),
+        ('0.0.2', metadata_schemas.VER_002, migrate_001_to_002),
+        ('0.0.3', metadata_schemas.VER_003, migrate_002_to_003)
+    ]
+
+    def __init__(self, metadata, migrate=True, target_version=None):
+        if not isinstance(metadata, dict):
+            raise TypeError("{} is not a dictionary".format(metadata))
+        starting_version = metadata.get('ver', '0.0.1')
+
+        StructuredDict.__init__(self, metadata, starting_version, migrate, target_version)
+
+
+def migrate_003_to_010(value):
+    migrated_to_003 = LegacyMetadata(value)
+    metadata = {
+        "version": "_0_1_0"
+    }
+    for k in ["author", "description", "language", "license", "nsfw", "thumbnail", "title",
+              "preview"]:
+        if k in migrated_to_003:
+            metadata.update({k: migrated_to_003[k]})
+
+    if 'license_url' in migrated_to_003:
+        metadata['licenseUrl'] = migrated_to_003['license_url']
+
+    if "fee" in migrated_to_003:
+        fee = migrated_to_003["fee"]
+        currency = list(fee.keys())[0]
+        amount = fee[currency]['amount']
+        address = fee[currency]['address']
+        metadata.update(dict(fee={"currency": currency, "version": "_0_0_1",
+                                    "amount": amount, "address": address}))
+    source = {
+        "source": migrated_to_003['sources']['lbry_sd_hash'],
+        "contentType": migrated_to_003['content_type'],
+        "sourceType": "lbry_sd_hash",
+        "version": "_0_0_1"
+    }
+
+    migrated = {
+        "version": "_0_0_1",
+        "claimType": "streamType",
+        "stream": {
+            "version": "_0_0_1",
+            "metadata": metadata,
+            "source": source
+        }
+    }
+    return ClaimDict.load_dict(migrated)
+
+
+def migrate(value):
+    return migrate_003_to_010(value)
diff --git a/lbrynet/winhelpers/__init__.py b/lbrynet/schema/proto/__init__.py
similarity index 100%
rename from lbrynet/winhelpers/__init__.py
rename to lbrynet/schema/proto/__init__.py
diff --git a/lbrynet/schema/proto/certificate.proto b/lbrynet/schema/proto/certificate.proto
new file mode 100644
index 000000000..dc5f66ea8
--- /dev/null
+++ b/lbrynet/schema/proto/certificate.proto
@@ -0,0 +1,18 @@
+syntax = "proto2";
+
+enum KeyType {
+        UNKNOWN_PUBLIC_KEY_TYPE = 0;
+        NIST256p = 1;
+        NIST384p = 2;
+        SECP256k1 = 3;
+}
+
+message Certificate {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+    }
+    required Version version = 1;
+    required KeyType keyType = 2;
+    required bytes publicKey = 4;
+}
diff --git a/lbrynet/schema/proto/certificate_pb2.py b/lbrynet/schema/proto/certificate_pb2.py
new file mode 100644
index 000000000..5412ff632
--- /dev/null
+++ b/lbrynet/schema/proto/certificate_pb2.py
@@ -0,0 +1,146 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/certificate.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/certificate.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n&lbrynet/schema/proto/certificate.proto\"\x8e\x01\n\x0b\x43\x65rtificate\x12%\n\x07version\x18\x01 \x02(\x0e\x32\x14.Certificate.Version\x12\x19\n\x07keyType\x18\x02 \x02(\x0e\x32\x08.KeyType\x12\x11\n\tpublicKey\x18\x04 \x02(\x0c\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01*Q\n\x07KeyType\x12\x1b\n\x17UNKNOWN_PUBLIC_KEY_TYPE\x10\x00\x12\x0c\n\x08NIST256p\x10\x01\x12\x0c\n\x08NIST384p\x10\x02\x12\r\n\tSECP256k1\x10\x03')
+)
+
+_KEYTYPE = _descriptor.EnumDescriptor(
+  name='KeyType',
+  full_name='KeyType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_PUBLIC_KEY_TYPE', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='NIST256p', index=1, number=1,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='NIST384p', index=2, number=2,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='SECP256k1', index=3, number=3,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=187,
+  serialized_end=268,
+)
+_sym_db.RegisterEnumDescriptor(_KEYTYPE)
+
+KeyType = enum_type_wrapper.EnumTypeWrapper(_KEYTYPE)
+UNKNOWN_PUBLIC_KEY_TYPE = 0
+NIST256p = 1
+NIST384p = 2
+SECP256k1 = 3
+
+
+_CERTIFICATE_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Certificate.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=143,
+  serialized_end=185,
+)
+_sym_db.RegisterEnumDescriptor(_CERTIFICATE_VERSION)
+
+
+_CERTIFICATE = _descriptor.Descriptor(
+  name='Certificate',
+  full_name='Certificate',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Certificate.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='keyType', full_name='Certificate.keyType', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='publicKey', full_name='Certificate.publicKey', index=2,
+      number=4, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b(""),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _CERTIFICATE_VERSION,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=43,
+  serialized_end=185,
+)
+
+_CERTIFICATE.fields_by_name['version'].enum_type = _CERTIFICATE_VERSION
+_CERTIFICATE.fields_by_name['keyType'].enum_type = _KEYTYPE
+_CERTIFICATE_VERSION.containing_type = _CERTIFICATE
+DESCRIPTOR.message_types_by_name['Certificate'] = _CERTIFICATE
+DESCRIPTOR.enum_types_by_name['KeyType'] = _KEYTYPE
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Certificate = _reflection.GeneratedProtocolMessageType('Certificate', (_message.Message,), dict(
+  DESCRIPTOR = _CERTIFICATE,
+  __module__ = 'lbrynet.schema.proto.certificate_pb2'
+  # @@protoc_insertion_point(class_scope:Certificate)
+  ))
+_sym_db.RegisterMessage(Certificate)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/proto/claim.proto b/lbrynet/schema/proto/claim.proto
new file mode 100644
index 000000000..f26098752
--- /dev/null
+++ b/lbrynet/schema/proto/claim.proto
@@ -0,0 +1,22 @@
+syntax = "proto2";
+
+import "lbrynet/schema/proto/stream.proto";
+import "lbrynet/schema/proto/certificate.proto";
+import "lbrynet/schema/proto/signature.proto";
+
+message Claim {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+    }
+    required Version version = 1;
+    enum ClaimType {
+        UNKNOWN_CLAIM_TYPE = 0;
+        streamType = 1;
+        certificateType = 2;
+    }
+    required ClaimType claimType = 2;
+    optional Stream stream = 3;
+    optional Certificate certificate = 4;
+    optional Signature publisherSignature = 5;
+}
diff --git a/lbrynet/schema/proto/claim_pb2.py b/lbrynet/schema/proto/claim_pb2.py
new file mode 100644
index 000000000..813270358
--- /dev/null
+++ b/lbrynet/schema/proto/claim_pb2.py
@@ -0,0 +1,158 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/claim.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from lbrynet.schema.proto import stream_pb2 as lbrynet_dot_schema_dot_proto_dot_stream__pb2
+from lbrynet.schema.proto import certificate_pb2 as lbrynet_dot_schema_dot_proto_dot_certificate__pb2
+from lbrynet.schema.proto import signature_pb2 as lbrynet_dot_schema_dot_proto_dot_signature__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/claim.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n lbrynet/schema/proto/claim.proto\x1a!lbrynet/schema/proto/stream.proto\x1a&lbrynet/schema/proto/certificate.proto\x1a$lbrynet/schema/proto/signature.proto\"\xa7\x02\n\x05\x43laim\x12\x1f\n\x07version\x18\x01 \x02(\x0e\x32\x0e.Claim.Version\x12#\n\tclaimType\x18\x02 \x02(\x0e\x32\x10.Claim.ClaimType\x12\x17\n\x06stream\x18\x03 \x01(\x0b\x32\x07.Stream\x12!\n\x0b\x63\x65rtificate\x18\x04 \x01(\x0b\x32\x0c.Certificate\x12&\n\x12publisherSignature\x18\x05 \x01(\x0b\x32\n.Signature\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01\"H\n\tClaimType\x12\x16\n\x12UNKNOWN_CLAIM_TYPE\x10\x00\x12\x0e\n\nstreamType\x10\x01\x12\x13\n\x0f\x63\x65rtificateType\x10\x02')
+  ,
+  dependencies=[lbrynet_dot_schema_dot_proto_dot_stream__pb2.DESCRIPTOR,lbrynet_dot_schema_dot_proto_dot_certificate__pb2.DESCRIPTOR,lbrynet_dot_schema_dot_proto_dot_signature__pb2.DESCRIPTOR,])
+
+
+
+_CLAIM_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Claim.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=329,
+  serialized_end=371,
+)
+_sym_db.RegisterEnumDescriptor(_CLAIM_VERSION)
+
+_CLAIM_CLAIMTYPE = _descriptor.EnumDescriptor(
+  name='ClaimType',
+  full_name='Claim.ClaimType',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_CLAIM_TYPE', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='streamType', index=1, number=1,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='certificateType', index=2, number=2,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=373,
+  serialized_end=445,
+)
+_sym_db.RegisterEnumDescriptor(_CLAIM_CLAIMTYPE)
+
+
+_CLAIM = _descriptor.Descriptor(
+  name='Claim',
+  full_name='Claim',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Claim.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='claimType', full_name='Claim.claimType', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='stream', full_name='Claim.stream', index=2,
+      number=3, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='certificate', full_name='Claim.certificate', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='publisherSignature', full_name='Claim.publisherSignature', index=4,
+      number=5, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _CLAIM_VERSION,
+    _CLAIM_CLAIMTYPE,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=150,
+  serialized_end=445,
+)
+
+_CLAIM.fields_by_name['version'].enum_type = _CLAIM_VERSION
+_CLAIM.fields_by_name['claimType'].enum_type = _CLAIM_CLAIMTYPE
+_CLAIM.fields_by_name['stream'].message_type = lbrynet_dot_schema_dot_proto_dot_stream__pb2._STREAM
+_CLAIM.fields_by_name['certificate'].message_type = lbrynet_dot_schema_dot_proto_dot_certificate__pb2._CERTIFICATE
+_CLAIM.fields_by_name['publisherSignature'].message_type = lbrynet_dot_schema_dot_proto_dot_signature__pb2._SIGNATURE
+_CLAIM_VERSION.containing_type = _CLAIM
+_CLAIM_CLAIMTYPE.containing_type = _CLAIM
+DESCRIPTOR.message_types_by_name['Claim'] = _CLAIM
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Claim = _reflection.GeneratedProtocolMessageType('Claim', (_message.Message,), dict(
+  DESCRIPTOR = _CLAIM,
+  __module__ = 'lbrynet.schema.proto.claim_pb2'
+  # @@protoc_insertion_point(class_scope:Claim)
+  ))
+_sym_db.RegisterMessage(Claim)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/proto/fee.proto b/lbrynet/schema/proto/fee.proto
new file mode 100644
index 000000000..c666eaa6c
--- /dev/null
+++ b/lbrynet/schema/proto/fee.proto
@@ -0,0 +1,18 @@
+syntax = "proto2";
+
+message Fee {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+    }
+    enum Currency {
+        UNKNOWN_CURRENCY = 0;
+        LBC = 1;
+        BTC = 2;
+        USD = 3;
+    }
+    required Version version = 1;
+    required Currency currency = 2;
+    required bytes address = 3;
+    required float amount = 4;
+}
diff --git a/lbrynet/schema/proto/fee_pb2.py b/lbrynet/schema/proto/fee_pb2.py
new file mode 100644
index 000000000..2f96f1cc3
--- /dev/null
+++ b/lbrynet/schema/proto/fee_pb2.py
@@ -0,0 +1,148 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/fee.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/fee.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n\x1elbrynet/schema/proto/fee.proto\"\xcf\x01\n\x03\x46\x65\x65\x12\x1d\n\x07version\x18\x01 \x02(\x0e\x32\x0c.Fee.Version\x12\x1f\n\x08\x63urrency\x18\x02 \x02(\x0e\x32\r.Fee.Currency\x12\x0f\n\x07\x61\x64\x64ress\x18\x03 \x02(\x0c\x12\x0e\n\x06\x61mount\x18\x04 \x02(\x02\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01\";\n\x08\x43urrency\x12\x14\n\x10UNKNOWN_CURRENCY\x10\x00\x12\x07\n\x03LBC\x10\x01\x12\x07\n\x03\x42TC\x10\x02\x12\x07\n\x03USD\x10\x03')
+)
+
+
+
+_FEE_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Fee.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=139,
+  serialized_end=181,
+)
+_sym_db.RegisterEnumDescriptor(_FEE_VERSION)
+
+_FEE_CURRENCY = _descriptor.EnumDescriptor(
+  name='Currency',
+  full_name='Fee.Currency',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_CURRENCY', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='LBC', index=1, number=1,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='BTC', index=2, number=2,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='USD', index=3, number=3,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=183,
+  serialized_end=242,
+)
+_sym_db.RegisterEnumDescriptor(_FEE_CURRENCY)
+
+
+_FEE = _descriptor.Descriptor(
+  name='Fee',
+  full_name='Fee',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Fee.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='currency', full_name='Fee.currency', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='address', full_name='Fee.address', index=2,
+      number=3, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b(""),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='amount', full_name='Fee.amount', index=3,
+      number=4, type=2, cpp_type=6, label=2,
+      has_default_value=False, default_value=float(0),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _FEE_VERSION,
+    _FEE_CURRENCY,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=35,
+  serialized_end=242,
+)
+
+_FEE.fields_by_name['version'].enum_type = _FEE_VERSION
+_FEE.fields_by_name['currency'].enum_type = _FEE_CURRENCY
+_FEE_VERSION.containing_type = _FEE
+_FEE_CURRENCY.containing_type = _FEE
+DESCRIPTOR.message_types_by_name['Fee'] = _FEE
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Fee = _reflection.GeneratedProtocolMessageType('Fee', (_message.Message,), dict(
+  DESCRIPTOR = _FEE,
+  __module__ = 'lbrynet.schema.proto.fee_pb2'
+  # @@protoc_insertion_point(class_scope:Fee)
+  ))
+_sym_db.RegisterMessage(Fee)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/proto/metadata.proto b/lbrynet/schema/proto/metadata.proto
new file mode 100644
index 000000000..bb4f52964
--- /dev/null
+++ b/lbrynet/schema/proto/metadata.proto
@@ -0,0 +1,212 @@
+syntax = "proto2";
+
+import "lbrynet/schema/proto/fee.proto";
+
+message Metadata {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+        _0_0_2 = 2;
+        _0_0_3 = 3;
+        _0_1_0 = 4;
+    }
+    enum Language {
+        UNKNOWN_LANGUAGE = 0;
+        en = 1;
+        aa = 2;
+        ab = 3;
+        ae = 4;
+        af = 5;
+        ak = 6;
+        am = 7;
+        an = 8;
+        ar = 9;
+        as = 10;
+        av = 11;
+        ay = 12;
+        az = 13;
+        ba = 14;
+        be = 15;
+        bg = 16;
+        bh = 17;
+        bi = 18;
+        bm = 19;
+        bn = 20;
+        bo = 21;
+        br = 22;
+        bs = 23;
+        ca = 24;
+        ce = 25;
+        ch = 26;
+        co = 27;
+        cr = 28;
+        cs = 29;
+        cu = 30;
+        cv = 31;
+        cy = 32;
+        da = 33;
+        de = 34;
+        dv = 35;
+        dz = 36;
+        ee = 37;
+        el = 38;
+        eo = 39;
+        es = 40;
+        et = 41;
+        eu = 42;
+        fa = 43;
+        ff = 44;
+        fi = 45;
+        fj = 46;
+        fo = 47;
+        fr = 48;
+        fy = 49;
+        ga = 50;
+        gd = 51;
+        gl = 52;
+        gn = 53;
+        gu = 54;
+        gv = 55;
+        ha = 56;
+        he = 57;
+        hi = 58;
+        ho = 59;
+        hr = 60;
+        ht = 61;
+        hu = 62;
+        hy = 63;
+        hz = 64;
+        ia = 65;
+        id = 66;
+        ie = 67;
+        ig = 68;
+        ii = 69;
+        ik = 70;
+        io = 71;
+        is = 72;
+        it = 73;
+        iu = 74;
+        ja = 75;
+        jv = 76;
+        ka = 77;
+        kg = 78;
+        ki = 79;
+        kj = 80;
+        kk = 81;
+        kl = 82;
+        km = 83;
+        kn = 84;
+        ko = 85;
+        kr = 86;
+        ks = 87;
+        ku = 88;
+        kv = 89;
+        kw = 90;
+        ky = 91;
+        la = 92;
+        lb = 93;
+        lg = 94;
+        li = 95;
+        ln = 96;
+        lo = 97;
+        lt = 98;
+        lu = 99;
+        lv = 100;
+        mg = 101;
+        mh = 102;
+        mi = 103;
+        mk = 104;
+        ml = 105;
+        mn = 106;
+        mr = 107;
+        ms = 108;
+        mt = 109;
+        my = 110;
+        na = 111;
+        nb = 112;
+        nd = 113;
+        ne = 114;
+        ng = 115;
+        nl = 116;
+        nn = 117;
+        no = 118;
+        nr = 119;
+        nv = 120;
+        ny = 121;
+        oc = 122;
+        oj = 123;
+        om = 124;
+        or = 125;
+        os = 126;
+        pa = 127;
+        pi = 128;
+        pl = 129;
+        ps = 130;
+        pt = 131;
+        qu = 132;
+        rm = 133;
+        rn = 134;
+        ro = 135;
+        ru = 136;
+        rw = 137;
+        sa = 138;
+        sc = 139;
+        sd = 140;
+        se = 141;
+        sg = 142;
+        si = 143;
+        sk = 144;
+        sl = 145;
+        sm = 146;
+        sn = 147;
+        so = 148;
+        sq = 149;
+        sr = 150;
+        ss = 151;
+        st = 152;
+        su = 153;
+        sv = 154;
+        sw = 155;
+        ta = 156;
+        te = 157;
+        tg = 158;
+        th = 159;
+        ti = 160;
+        tk = 161;
+        tl = 162;
+        tn = 163;
+        to = 164;
+        tr = 165;
+        ts = 166;
+        tt = 167;
+        tw = 168;
+        ty = 169;
+        ug = 170;
+        uk = 171;
+        ur = 172;
+        uz = 173;
+        ve = 174;
+        vi = 175;
+        vo = 176;
+        wa = 177;
+        wo = 178;
+        xh = 179;
+        yi = 180;
+        yo = 181;
+        za = 182;
+        zh = 183;
+        zu = 184;
+    }
+    required Version version = 1;
+    required Language language = 2;
+    required string title = 3;
+    required string description = 4;
+    required string author = 5;
+    required string license = 6;
+    required bool nsfw = 7;
+
+    optional Fee fee = 8;
+    optional string thumbnail = 9;
+    optional string preview = 10;
+    optional string licenseUrl = 11;
+}
diff --git a/lbrynet/schema/proto/metadata_pb2.py b/lbrynet/schema/proto/metadata_pb2.py
new file mode 100644
index 000000000..617193ff4
--- /dev/null
+++ b/lbrynet/schema/proto/metadata_pb2.py
@@ -0,0 +1,936 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/metadata.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from lbrynet.schema.proto import fee_pb2 as lbrynet_dot_schema_dot_proto_dot_fee__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/metadata.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n#lbrynet/schema/proto/metadata.proto\x1a\x1elbrynet/schema/proto/fee.proto\"\xde\x0e\n\x08Metadata\x12\"\n\x07version\x18\x01 \x02(\x0e\x32\x11.Metadata.Version\x12$\n\x08language\x18\x02 \x02(\x0e\x32\x12.Metadata.Language\x12\r\n\x05title\x18\x03 \x02(\t\x12\x13\n\x0b\x64\x65scription\x18\x04 \x02(\t\x12\x0e\n\x06\x61uthor\x18\x05 \x02(\t\x12\x0f\n\x07license\x18\x06 \x02(\t\x12\x0c\n\x04nsfw\x18\x07 \x02(\x08\x12\x11\n\x03\x66\x65\x65\x18\x08 \x01(\x0b\x32\x04.Fee\x12\x11\n\tthumbnail\x18\t \x01(\t\x12\x0f\n\x07preview\x18\n \x01(\t\x12\x12\n\nlicenseUrl\x18\x0b \x01(\t\"N\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01\x12\n\n\x06_0_0_2\x10\x02\x12\n\n\x06_0_0_3\x10\x03\x12\n\n\x06_0_1_0\x10\x04\"\x99\x0c\n\x08Language\x12\x14\n\x10UNKNOWN_LANGUAGE\x10\x00\x12\x06\n\x02\x65n\x10\x01\x12\x06\n\x02\x61\x61\x10\x02\x12\x06\n\x02\x61\x62\x10\x03\x12\x06\n\x02\x61\x65\x10\x04\x12\x06\n\x02\x61\x66\x10\x05\x12\x06\n\x02\x61k\x10\x06\x12\x06\n\x02\x61m\x10\x07\x12\x06\n\x02\x61n\x10\x08\x12\x06\n\x02\x61r\x10\t\x12\x06\n\x02\x61s\x10\n\x12\x06\n\x02\x61v\x10\x0b\x12\x06\n\x02\x61y\x10\x0c\x12\x06\n\x02\x61z\x10\r\x12\x06\n\x02\x62\x61\x10\x0e\x12\x06\n\x02\x62\x65\x10\x0f\x12\x06\n\x02\x62g\x10\x10\x12\x06\n\x02\x62h\x10\x11\x12\x06\n\x02\x62i\x10\x12\x12\x06\n\x02\x62m\x10\x13\x12\x06\n\x02\x62n\x10\x14\x12\x06\n\x02\x62o\x10\x15\x12\x06\n\x02\x62r\x10\x16\x12\x06\n\x02\x62s\x10\x17\x12\x06\n\x02\x63\x61\x10\x18\x12\x06\n\x02\x63\x65\x10\x19\x12\x06\n\x02\x63h\x10\x1a\x12\x06\n\x02\x63o\x10\x1b\x12\x06\n\x02\x63r\x10\x1c\x12\x06\n\x02\x63s\x10\x1d\x12\x06\n\x02\x63u\x10\x1e\x12\x06\n\x02\x63v\x10\x1f\x12\x06\n\x02\x63y\x10 \x12\x06\n\x02\x64\x61\x10!\x12\x06\n\x02\x64\x65\x10\"\x12\x06\n\x02\x64v\x10#\x12\x06\n\x02\x64z\x10$\x12\x06\n\x02\x65\x65\x10%\x12\x06\n\x02\x65l\x10&\x12\x06\n\x02\x65o\x10\'\x12\x06\n\x02\x65s\x10(\x12\x06\n\x02\x65t\x10)\x12\x06\n\x02\x65u\x10*\x12\x06\n\x02\x66\x61\x10+\x12\x06\n\x02\x66\x66\x10,\x12\x06\n\x02\x66i\x10-\x12\x06\n\x02\x66j\x10.\x12\x06\n\x02\x66o\x10/\x12\x06\n\x02\x66r\x10\x30\x12\x06\n\x02\x66y\x10\x31\x12\x06\n\x02ga\x10\x32\x12\x06\n\x02gd\x10\x33\x12\x06\n\x02gl\x10\x34\x12\x06\n\x02gn\x10\x35\x12\x06\n\x02gu\x10\x36\x12\x06\n\x02gv\x10\x37\x12\x06\n\x02ha\x10\x38\x12\x06\n\x02he\x10\x39\x12\x06\n\x02hi\x10:\x12\x06\n\x02ho\x10;\x12\x06\n\x02hr\x10<\x12\x06\n\x02ht\x10=\x12\x06\n\x02hu\x10>\x12\x06\n\x02hy\x10?\x12\x06\n\x02hz\x10@\x12\x06\n\x02ia\x10\x41\x12\x06\n\x02id\x10\x42\x12\x06\n\x02ie\x10\x43\x12\x06\n\x02ig\x10\x44\x12\x06\n\x02ii\x10\x45\x12\x06\n\x02ik\x10\x46\x12\x06\n\x02io\x10G\x12\x06\n\x02is\x10H\x12\x06\n\x02it\x10I\x12\x06\n\x02iu\x10J\x12\x06\n\x02ja\x10K\x12\x06\n\x02jv\x10L\x12\x06\n\x02ka\x10M\x12\x06\n\x02kg\x10N\x12\x06\n\x02ki\x10O\x12\x06\n\x02kj\x10P\x12\x06\n\x02kk\x10Q\x12\x06\n\x02kl\x10R\x12\x06\n\x02km\x10S\x12\x06\n\x02kn\x10T\x12\x06\n\x02ko\x10U\x12\x06\n\x02kr\x10V\x12\x06\n\x02ks\x10W\x12\x06\n\x02ku\x10X\x12\x06\n\x02kv\x10Y\x12\x06\n\x02kw\x10Z\x12\x06\n\x02ky\x10[\x12\x06\n\x02la\x10\\\x12\x06\n\x02lb\x10]\x12\x06\n\x02lg\x10^\x12\x06\n\x02li\x10_\x12\x06\n\x02ln\x10`\x12\x06\n\x02lo\x10\x61\x12\x06\n\x02lt\x10\x62\x12\x06\n\x02lu\x10\x63\x12\x06\n\x02lv\x10\x64\x12\x06\n\x02mg\x10\x65\x12\x06\n\x02mh\x10\x66\x12\x06\n\x02mi\x10g\x12\x06\n\x02mk\x10h\x12\x06\n\x02ml\x10i\x12\x06\n\x02mn\x10j\x12\x06\n\x02mr\x10k\x12\x06\n\x02ms\x10l\x12\x06\n\x02mt\x10m\x12\x06\n\x02my\x10n\x12\x06\n\x02na\x10o\x12\x06\n\x02nb\x10p\x12\x06\n\x02nd\x10q\x12\x06\n\x02ne\x10r\x12\x06\n\x02ng\x10s\x12\x06\n\x02nl\x10t\x12\x06\n\x02nn\x10u\x12\x06\n\x02no\x10v\x12\x06\n\x02nr\x10w\x12\x06\n\x02nv\x10x\x12\x06\n\x02ny\x10y\x12\x06\n\x02oc\x10z\x12\x06\n\x02oj\x10{\x12\x06\n\x02om\x10|\x12\x06\n\x02or\x10}\x12\x06\n\x02os\x10~\x12\x06\n\x02pa\x10\x7f\x12\x07\n\x02pi\x10\x80\x01\x12\x07\n\x02pl\x10\x81\x01\x12\x07\n\x02ps\x10\x82\x01\x12\x07\n\x02pt\x10\x83\x01\x12\x07\n\x02qu\x10\x84\x01\x12\x07\n\x02rm\x10\x85\x01\x12\x07\n\x02rn\x10\x86\x01\x12\x07\n\x02ro\x10\x87\x01\x12\x07\n\x02ru\x10\x88\x01\x12\x07\n\x02rw\x10\x89\x01\x12\x07\n\x02sa\x10\x8a\x01\x12\x07\n\x02sc\x10\x8b\x01\x12\x07\n\x02sd\x10\x8c\x01\x12\x07\n\x02se\x10\x8d\x01\x12\x07\n\x02sg\x10\x8e\x01\x12\x07\n\x02si\x10\x8f\x01\x12\x07\n\x02sk\x10\x90\x01\x12\x07\n\x02sl\x10\x91\x01\x12\x07\n\x02sm\x10\x92\x01\x12\x07\n\x02sn\x10\x93\x01\x12\x07\n\x02so\x10\x94\x01\x12\x07\n\x02sq\x10\x95\x01\x12\x07\n\x02sr\x10\x96\x01\x12\x07\n\x02ss\x10\x97\x01\x12\x07\n\x02st\x10\x98\x01\x12\x07\n\x02su\x10\x99\x01\x12\x07\n\x02sv\x10\x9a\x01\x12\x07\n\x02sw\x10\x9b\x01\x12\x07\n\x02ta\x10\x9c\x01\x12\x07\n\x02te\x10\x9d\x01\x12\x07\n\x02tg\x10\x9e\x01\x12\x07\n\x02th\x10\x9f\x01\x12\x07\n\x02ti\x10\xa0\x01\x12\x07\n\x02tk\x10\xa1\x01\x12\x07\n\x02tl\x10\xa2\x01\x12\x07\n\x02tn\x10\xa3\x01\x12\x07\n\x02to\x10\xa4\x01\x12\x07\n\x02tr\x10\xa5\x01\x12\x07\n\x02ts\x10\xa6\x01\x12\x07\n\x02tt\x10\xa7\x01\x12\x07\n\x02tw\x10\xa8\x01\x12\x07\n\x02ty\x10\xa9\x01\x12\x07\n\x02ug\x10\xaa\x01\x12\x07\n\x02uk\x10\xab\x01\x12\x07\n\x02ur\x10\xac\x01\x12\x07\n\x02uz\x10\xad\x01\x12\x07\n\x02ve\x10\xae\x01\x12\x07\n\x02vi\x10\xaf\x01\x12\x07\n\x02vo\x10\xb0\x01\x12\x07\n\x02wa\x10\xb1\x01\x12\x07\n\x02wo\x10\xb2\x01\x12\x07\n\x02xh\x10\xb3\x01\x12\x07\n\x02yi\x10\xb4\x01\x12\x07\n\x02yo\x10\xb5\x01\x12\x07\n\x02za\x10\xb6\x01\x12\x07\n\x02zh\x10\xb7\x01\x12\x07\n\x02zu\x10\xb8\x01')
+  ,
+  dependencies=[lbrynet_dot_schema_dot_proto_dot_fee__pb2.DESCRIPTOR,])
+
+
+
+_METADATA_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Metadata.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_2', index=2, number=2,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_3', index=3, number=3,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_1_0', index=4, number=4,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=316,
+  serialized_end=394,
+)
+_sym_db.RegisterEnumDescriptor(_METADATA_VERSION)
+
+_METADATA_LANGUAGE = _descriptor.EnumDescriptor(
+  name='Language',
+  full_name='Metadata.Language',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_LANGUAGE', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='en', index=1, number=1,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='aa', index=2, number=2,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ab', index=3, number=3,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ae', index=4, number=4,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='af', index=5, number=5,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ak', index=6, number=6,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='am', index=7, number=7,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='an', index=8, number=8,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ar', index=9, number=9,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='as', index=10, number=10,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='av', index=11, number=11,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ay', index=12, number=12,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='az', index=13, number=13,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ba', index=14, number=14,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='be', index=15, number=15,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bg', index=16, number=16,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bh', index=17, number=17,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bi', index=18, number=18,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bm', index=19, number=19,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bn', index=20, number=20,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bo', index=21, number=21,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='br', index=22, number=22,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='bs', index=23, number=23,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ca', index=24, number=24,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ce', index=25, number=25,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ch', index=26, number=26,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='co', index=27, number=27,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='cr', index=28, number=28,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='cs', index=29, number=29,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='cu', index=30, number=30,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='cv', index=31, number=31,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='cy', index=32, number=32,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='da', index=33, number=33,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='de', index=34, number=34,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='dv', index=35, number=35,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='dz', index=36, number=36,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ee', index=37, number=37,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='el', index=38, number=38,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='eo', index=39, number=39,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='es', index=40, number=40,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='et', index=41, number=41,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='eu', index=42, number=42,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='fa', index=43, number=43,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ff', index=44, number=44,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='fi', index=45, number=45,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='fj', index=46, number=46,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='fo', index=47, number=47,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='fr', index=48, number=48,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='fy', index=49, number=49,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ga', index=50, number=50,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='gd', index=51, number=51,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='gl', index=52, number=52,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='gn', index=53, number=53,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='gu', index=54, number=54,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='gv', index=55, number=55,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ha', index=56, number=56,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='he', index=57, number=57,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='hi', index=58, number=58,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ho', index=59, number=59,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='hr', index=60, number=60,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ht', index=61, number=61,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='hu', index=62, number=62,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='hy', index=63, number=63,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='hz', index=64, number=64,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ia', index=65, number=65,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='id', index=66, number=66,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ie', index=67, number=67,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ig', index=68, number=68,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ii', index=69, number=69,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ik', index=70, number=70,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='io', index=71, number=71,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='is', index=72, number=72,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='it', index=73, number=73,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='iu', index=74, number=74,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ja', index=75, number=75,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='jv', index=76, number=76,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ka', index=77, number=77,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kg', index=78, number=78,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ki', index=79, number=79,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kj', index=80, number=80,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kk', index=81, number=81,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kl', index=82, number=82,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='km', index=83, number=83,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kn', index=84, number=84,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ko', index=85, number=85,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kr', index=86, number=86,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ks', index=87, number=87,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ku', index=88, number=88,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kv', index=89, number=89,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='kw', index=90, number=90,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ky', index=91, number=91,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='la', index=92, number=92,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lb', index=93, number=93,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lg', index=94, number=94,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='li', index=95, number=95,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ln', index=96, number=96,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lo', index=97, number=97,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lt', index=98, number=98,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lu', index=99, number=99,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lv', index=100, number=100,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mg', index=101, number=101,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mh', index=102, number=102,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mi', index=103, number=103,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mk', index=104, number=104,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ml', index=105, number=105,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mn', index=106, number=106,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mr', index=107, number=107,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ms', index=108, number=108,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='mt', index=109, number=109,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='my', index=110, number=110,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='na', index=111, number=111,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='nb', index=112, number=112,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='nd', index=113, number=113,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ne', index=114, number=114,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ng', index=115, number=115,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='nl', index=116, number=116,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='nn', index=117, number=117,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='no', index=118, number=118,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='nr', index=119, number=119,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='nv', index=120, number=120,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ny', index=121, number=121,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='oc', index=122, number=122,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='oj', index=123, number=123,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='om', index=124, number=124,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='or', index=125, number=125,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='os', index=126, number=126,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='pa', index=127, number=127,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='pi', index=128, number=128,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='pl', index=129, number=129,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ps', index=130, number=130,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='pt', index=131, number=131,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='qu', index=132, number=132,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='rm', index=133, number=133,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='rn', index=134, number=134,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ro', index=135, number=135,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ru', index=136, number=136,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='rw', index=137, number=137,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sa', index=138, number=138,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sc', index=139, number=139,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sd', index=140, number=140,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='se', index=141, number=141,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sg', index=142, number=142,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='si', index=143, number=143,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sk', index=144, number=144,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sl', index=145, number=145,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sm', index=146, number=146,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sn', index=147, number=147,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='so', index=148, number=148,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sq', index=149, number=149,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sr', index=150, number=150,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ss', index=151, number=151,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='st', index=152, number=152,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='su', index=153, number=153,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sv', index=154, number=154,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='sw', index=155, number=155,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ta', index=156, number=156,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='te', index=157, number=157,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tg', index=158, number=158,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='th', index=159, number=159,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ti', index=160, number=160,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tk', index=161, number=161,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tl', index=162, number=162,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tn', index=163, number=163,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='to', index=164, number=164,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tr', index=165, number=165,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ts', index=166, number=166,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tt', index=167, number=167,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='tw', index=168, number=168,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ty', index=169, number=169,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ug', index=170, number=170,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='uk', index=171, number=171,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ur', index=172, number=172,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='uz', index=173, number=173,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='ve', index=174, number=174,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='vi', index=175, number=175,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='vo', index=176, number=176,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='wa', index=177, number=177,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='wo', index=178, number=178,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='xh', index=179, number=179,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='yi', index=180, number=180,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='yo', index=181, number=181,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='za', index=182, number=182,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='zh', index=183, number=183,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='zu', index=184, number=184,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=397,
+  serialized_end=1958,
+)
+_sym_db.RegisterEnumDescriptor(_METADATA_LANGUAGE)
+
+
+_METADATA = _descriptor.Descriptor(
+  name='Metadata',
+  full_name='Metadata',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Metadata.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='language', full_name='Metadata.language', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='title', full_name='Metadata.title', index=2,
+      number=3, type=9, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='description', full_name='Metadata.description', index=3,
+      number=4, type=9, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='author', full_name='Metadata.author', index=4,
+      number=5, type=9, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='license', full_name='Metadata.license', index=5,
+      number=6, type=9, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='nsfw', full_name='Metadata.nsfw', index=6,
+      number=7, type=8, cpp_type=7, label=2,
+      has_default_value=False, default_value=False,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='fee', full_name='Metadata.fee', index=7,
+      number=8, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='thumbnail', full_name='Metadata.thumbnail', index=8,
+      number=9, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='preview', full_name='Metadata.preview', index=9,
+      number=10, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='licenseUrl', full_name='Metadata.licenseUrl', index=10,
+      number=11, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _METADATA_VERSION,
+    _METADATA_LANGUAGE,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=72,
+  serialized_end=1958,
+)
+
+_METADATA.fields_by_name['version'].enum_type = _METADATA_VERSION
+_METADATA.fields_by_name['language'].enum_type = _METADATA_LANGUAGE
+_METADATA.fields_by_name['fee'].message_type = lbrynet_dot_schema_dot_proto_dot_fee__pb2._FEE
+_METADATA_VERSION.containing_type = _METADATA
+_METADATA_LANGUAGE.containing_type = _METADATA
+DESCRIPTOR.message_types_by_name['Metadata'] = _METADATA
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Metadata = _reflection.GeneratedProtocolMessageType('Metadata', (_message.Message,), dict(
+  DESCRIPTOR = _METADATA,
+  __module__ = 'lbrynet.schema.proto.metadata_pb2'
+  # @@protoc_insertion_point(class_scope:Metadata)
+  ))
+_sym_db.RegisterMessage(Metadata)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/proto/signature.proto b/lbrynet/schema/proto/signature.proto
new file mode 100644
index 000000000..19d227ab8
--- /dev/null
+++ b/lbrynet/schema/proto/signature.proto
@@ -0,0 +1,14 @@
+syntax = "proto2";
+
+import "lbrynet/schema/proto/certificate.proto";
+
+message Signature {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+    }
+    required Version version = 1;
+    required KeyType signatureType = 2;
+    required bytes signature = 3;
+    required bytes certificateId = 4;
+}
diff --git a/lbrynet/schema/proto/signature_pb2.py b/lbrynet/schema/proto/signature_pb2.py
new file mode 100644
index 000000000..d8dfbdc67
--- /dev/null
+++ b/lbrynet/schema/proto/signature_pb2.py
@@ -0,0 +1,118 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/signature.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from lbrynet.schema.proto import certificate_pb2 as lbrynet_dot_schema_dot_proto_dot_certificate__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/signature.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n$lbrynet/schema/proto/signature.proto\x1a&lbrynet/schema/proto/certificate.proto\"\xa7\x01\n\tSignature\x12#\n\x07version\x18\x01 \x02(\x0e\x32\x12.Signature.Version\x12\x1f\n\rsignatureType\x18\x02 \x02(\x0e\x32\x08.KeyType\x12\x11\n\tsignature\x18\x03 \x02(\x0c\x12\x15\n\rcertificateId\x18\x04 \x02(\x0c\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01')
+  ,
+  dependencies=[lbrynet_dot_schema_dot_proto_dot_certificate__pb2.DESCRIPTOR,])
+
+
+
+_SIGNATURE_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Signature.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=206,
+  serialized_end=248,
+)
+_sym_db.RegisterEnumDescriptor(_SIGNATURE_VERSION)
+
+
+_SIGNATURE = _descriptor.Descriptor(
+  name='Signature',
+  full_name='Signature',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Signature.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='signatureType', full_name='Signature.signatureType', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='signature', full_name='Signature.signature', index=2,
+      number=3, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b(""),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='certificateId', full_name='Signature.certificateId', index=3,
+      number=4, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b(""),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _SIGNATURE_VERSION,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=81,
+  serialized_end=248,
+)
+
+_SIGNATURE.fields_by_name['version'].enum_type = _SIGNATURE_VERSION
+_SIGNATURE.fields_by_name['signatureType'].enum_type = lbrynet_dot_schema_dot_proto_dot_certificate__pb2._KEYTYPE
+_SIGNATURE_VERSION.containing_type = _SIGNATURE
+DESCRIPTOR.message_types_by_name['Signature'] = _SIGNATURE
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Signature = _reflection.GeneratedProtocolMessageType('Signature', (_message.Message,), dict(
+  DESCRIPTOR = _SIGNATURE,
+  __module__ = 'lbrynet.schema.proto.signature_pb2'
+  # @@protoc_insertion_point(class_scope:Signature)
+  ))
+_sym_db.RegisterMessage(Signature)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/proto/source.proto b/lbrynet/schema/proto/source.proto
new file mode 100644
index 000000000..1e13afa4f
--- /dev/null
+++ b/lbrynet/schema/proto/source.proto
@@ -0,0 +1,16 @@
+syntax = "proto2";
+
+message Source {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+    }
+    required Version version = 1;
+    enum SourceTypes {
+        UNKNOWN_SOURCE_TYPE = 0;
+        lbry_sd_hash = 1;
+    }
+    required SourceTypes sourceType = 2;
+    required bytes source = 3;
+    required string contentType = 4;
+}
\ No newline at end of file
diff --git a/lbrynet/schema/proto/source_pb2.py b/lbrynet/schema/proto/source_pb2.py
new file mode 100644
index 000000000..d50d09be9
--- /dev/null
+++ b/lbrynet/schema/proto/source_pb2.py
@@ -0,0 +1,140 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/source.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/source.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n!lbrynet/schema/proto/source.proto\"\xde\x01\n\x06Source\x12 \n\x07version\x18\x01 \x02(\x0e\x32\x0f.Source.Version\x12\'\n\nsourceType\x18\x02 \x02(\x0e\x32\x13.Source.SourceTypes\x12\x0e\n\x06source\x18\x03 \x02(\x0c\x12\x13\n\x0b\x63ontentType\x18\x04 \x02(\t\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01\"8\n\x0bSourceTypes\x12\x17\n\x13UNKNOWN_SOURCE_TYPE\x10\x00\x12\x10\n\x0clbry_sd_hash\x10\x01')
+)
+
+
+
+_SOURCE_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Source.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=160,
+  serialized_end=202,
+)
+_sym_db.RegisterEnumDescriptor(_SOURCE_VERSION)
+
+_SOURCE_SOURCETYPES = _descriptor.EnumDescriptor(
+  name='SourceTypes',
+  full_name='Source.SourceTypes',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_SOURCE_TYPE', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='lbry_sd_hash', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=204,
+  serialized_end=260,
+)
+_sym_db.RegisterEnumDescriptor(_SOURCE_SOURCETYPES)
+
+
+_SOURCE = _descriptor.Descriptor(
+  name='Source',
+  full_name='Source',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Source.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='sourceType', full_name='Source.sourceType', index=1,
+      number=2, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='source', full_name='Source.source', index=2,
+      number=3, type=12, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b(""),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='contentType', full_name='Source.contentType', index=3,
+      number=4, type=9, cpp_type=9, label=2,
+      has_default_value=False, default_value=_b("").decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _SOURCE_VERSION,
+    _SOURCE_SOURCETYPES,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=38,
+  serialized_end=260,
+)
+
+_SOURCE.fields_by_name['version'].enum_type = _SOURCE_VERSION
+_SOURCE.fields_by_name['sourceType'].enum_type = _SOURCE_SOURCETYPES
+_SOURCE_VERSION.containing_type = _SOURCE
+_SOURCE_SOURCETYPES.containing_type = _SOURCE
+DESCRIPTOR.message_types_by_name['Source'] = _SOURCE
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Source = _reflection.GeneratedProtocolMessageType('Source', (_message.Message,), dict(
+  DESCRIPTOR = _SOURCE,
+  __module__ = 'lbrynet.schema.proto.source_pb2'
+  # @@protoc_insertion_point(class_scope:Source)
+  ))
+_sym_db.RegisterMessage(Source)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/proto/stream.proto b/lbrynet/schema/proto/stream.proto
new file mode 100644
index 000000000..51890475d
--- /dev/null
+++ b/lbrynet/schema/proto/stream.proto
@@ -0,0 +1,15 @@
+syntax = "proto2";
+
+import "lbrynet/schema/proto/metadata.proto";
+import "lbrynet/schema/proto/source.proto";
+
+
+message Stream {
+    enum Version {
+        UNKNOWN_VERSION = 0;
+        _0_0_1 = 1;
+    }
+    required Version version = 1;
+    required Metadata metadata = 2;
+    required Source source = 3;
+}
diff --git a/lbrynet/schema/proto/stream_pb2.py b/lbrynet/schema/proto/stream_pb2.py
new file mode 100644
index 000000000..b18a5b773
--- /dev/null
+++ b/lbrynet/schema/proto/stream_pb2.py
@@ -0,0 +1,113 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: lbrynet/schema/proto/stream.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from lbrynet.schema.proto import metadata_pb2 as lbrynet_dot_schema_dot_proto_dot_metadata__pb2
+from lbrynet.schema.proto import source_pb2 as lbrynet_dot_schema_dot_proto_dot_source__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='lbrynet/schema/proto/stream.proto',
+  package='',
+  syntax='proto2',
+  serialized_options=None,
+  serialized_pb=_b('\n!lbrynet/schema/proto/stream.proto\x1a#lbrynet/schema/proto/metadata.proto\x1a!lbrynet/schema/proto/source.proto\"\x8c\x01\n\x06Stream\x12 \n\x07version\x18\x01 \x02(\x0e\x32\x0f.Stream.Version\x12\x1b\n\x08metadata\x18\x02 \x02(\x0b\x32\t.Metadata\x12\x17\n\x06source\x18\x03 \x02(\x0b\x32\x07.Source\"*\n\x07Version\x12\x13\n\x0fUNKNOWN_VERSION\x10\x00\x12\n\n\x06_0_0_1\x10\x01')
+  ,
+  dependencies=[lbrynet_dot_schema_dot_proto_dot_metadata__pb2.DESCRIPTOR,lbrynet_dot_schema_dot_proto_dot_source__pb2.DESCRIPTOR,])
+
+
+
+_STREAM_VERSION = _descriptor.EnumDescriptor(
+  name='Version',
+  full_name='Stream.Version',
+  filename=None,
+  file=DESCRIPTOR,
+  values=[
+    _descriptor.EnumValueDescriptor(
+      name='UNKNOWN_VERSION', index=0, number=0,
+      serialized_options=None,
+      type=None),
+    _descriptor.EnumValueDescriptor(
+      name='_0_0_1', index=1, number=1,
+      serialized_options=None,
+      type=None),
+  ],
+  containing_type=None,
+  serialized_options=None,
+  serialized_start=208,
+  serialized_end=250,
+)
+_sym_db.RegisterEnumDescriptor(_STREAM_VERSION)
+
+
+_STREAM = _descriptor.Descriptor(
+  name='Stream',
+  full_name='Stream',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='version', full_name='Stream.version', index=0,
+      number=1, type=14, cpp_type=8, label=2,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='metadata', full_name='Stream.metadata', index=1,
+      number=2, type=11, cpp_type=10, label=2,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+    _descriptor.FieldDescriptor(
+      name='source', full_name='Stream.source', index=2,
+      number=3, type=11, cpp_type=10, label=2,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+    _STREAM_VERSION,
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto2',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=110,
+  serialized_end=250,
+)
+
+_STREAM.fields_by_name['version'].enum_type = _STREAM_VERSION
+_STREAM.fields_by_name['metadata'].message_type = lbrynet_dot_schema_dot_proto_dot_metadata__pb2._METADATA
+_STREAM.fields_by_name['source'].message_type = lbrynet_dot_schema_dot_proto_dot_source__pb2._SOURCE
+_STREAM_VERSION.containing_type = _STREAM
+DESCRIPTOR.message_types_by_name['Stream'] = _STREAM
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+Stream = _reflection.GeneratedProtocolMessageType('Stream', (_message.Message,), dict(
+  DESCRIPTOR = _STREAM,
+  __module__ = 'lbrynet.schema.proto.stream_pb2'
+  # @@protoc_insertion_point(class_scope:Stream)
+  ))
+_sym_db.RegisterMessage(Stream)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/lbrynet/schema/schema/__init__.py b/lbrynet/schema/schema/__init__.py
new file mode 100644
index 000000000..aeff1b4bc
--- /dev/null
+++ b/lbrynet/schema/schema/__init__.py
@@ -0,0 +1,102 @@
+V_0_0_1 = "_0_0_1"
+V_0_0_2 = "_0_0_2"
+V_0_0_3 = "_0_0_3"
+V_0_1_0 = "_0_1_0"
+
+
+VERSION_MAP = {
+    V_0_0_1: 1,
+    V_0_0_2: 2,
+    V_0_0_3: 3,
+    V_0_1_0: 4,
+}
+
+VERSION_NAMES = {
+    1: V_0_0_1,
+    2: V_0_0_2,
+    3: V_0_0_3,
+    4: V_0_1_0
+}
+
+LBC = "LBC"
+BTC = "BTC"
+USD = "USD"
+
+CURRENCY_MAP = {
+    LBC: 1,
+    BTC: 2,
+    USD: 3
+}
+
+CURRENCY_NAMES = {
+    1: LBC,
+    2: BTC,
+    3: USD
+}
+
+ADDRESS_LENGTH = 25
+ADDRESS_CHECKSUM_LENGTH = 4
+
+VERSION = "version"
+STREAM_TYPE = "streamType"
+CERTIFICATE_TYPE = "certificateType"
+CLAIM_TYPE = "claimType"
+SIGNATURE = "publisherSignature"
+
+CLAIM_TYPES = {
+    STREAM_TYPE: "stream",
+    CERTIFICATE_TYPE: "certificate"
+}
+
+CLAIM_TYPE_NAMES = {
+    1: "stream",
+    2: "certificate"
+}
+
+LBRY_SD_HASH = "lbry_sd_hash"
+LBRY_SD_HASH_LENGTH = 48
+
+SOURCE_TYPES = {
+    LBRY_SD_HASH: 1
+}
+
+NIST256p = "NIST256p"
+NIST384p = "NIST384p"
+SECP256k1 = "SECP256k1"
+
+ECDSA_CURVES = {
+    NIST256p: 1,
+    NIST384p: 2,
+    SECP256k1: 3
+}
+
+CURVE_NAMES = {
+    1: NIST256p,
+    2: NIST384p,
+    3: SECP256k1
+}
+
+SHA256 = "sha256"
+SHA384 = "sha384"
+
+
+B58_CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+assert len(B58_CHARS) == 58
+
+PUBKEY_ADDRESS = 0
+SCRIPT_ADDRESS = 5
+
+ADDRESS_PREFIXES = {
+    "lbrycrd_main": {
+        PUBKEY_ADDRESS: 85,
+        SCRIPT_ADDRESS: 122
+    },
+    "lbrycrd_regtest": {
+        PUBKEY_ADDRESS: 111,
+        SCRIPT_ADDRESS: 196
+    },
+    "lbrycrd_testnet": {
+        PUBKEY_ADDRESS: 111,
+        SCRIPT_ADDRESS: 196
+    },
+}
diff --git a/lbrynet/schema/schema/certificate.py b/lbrynet/schema/schema/certificate.py
new file mode 100644
index 000000000..5bdaf2a35
--- /dev/null
+++ b/lbrynet/schema/schema/certificate.py
@@ -0,0 +1,54 @@
+from copy import deepcopy
+
+from lbrynet.schema.proto import certificate_pb2 as cert_pb
+from lbrynet.schema.schema.schema import Schema
+from lbrynet.schema.schema import VERSION_MAP, V_0_0_1, ECDSA_CURVES, CURVE_NAMES
+from lbrynet.schema.validator import get_key_type_from_dem
+
+
+class _ECDSAKeyHelper(object):
+    def __init__(self, key):
+        self._key = key
+
+    @property
+    def der(self):
+        return self._key.to_der()
+
+    @property
+    def curve_name(self):
+        return self._key.curve.name
+
+
+class Certificate(Schema):
+    @classmethod
+    def load(cls, message):
+        _key = deepcopy(message)
+        _message_pb = cert_pb.Certificate()
+        if isinstance(_key, dict):
+            _message_pb.publicKey = _key.pop("publicKey")
+            _message_pb.version = VERSION_MAP[_key.pop("version")]
+            _message_pb.keyType = ECDSA_CURVES[_key.pop("keyType")]
+        else:
+            _message_pb.version = _key.version
+            _message_pb.keyType = _key.keyType
+            _message_pb.publicKey = _key.publicKey
+        if _message_pb.keyType not in CURVE_NAMES:
+            raise Exception("Unknown curve")
+        if get_key_type_from_dem(_message_pb.publicKey) != _message_pb.keyType:
+            raise Exception("Curve mismatch")
+        return cls._load(_key, _message_pb)
+
+    @classmethod
+    def load_from_key_obj(cls, key, key_type):
+        if key_type in ECDSA_CURVES:
+            _key = _ECDSAKeyHelper(key)
+        else:
+            raise Exception("Unknown key type: %s" % str(type(key)))
+        if key_type != _key.curve_name:
+            raise Exception("Curve mismatch")
+        msg = {
+            "version": V_0_0_1,
+            "keyType": key_type,
+            "publicKey": _key.der,
+        }
+        return cls.load(msg)
diff --git a/lbrynet/schema/schema/claim.py b/lbrynet/schema/schema/claim.py
new file mode 100644
index 000000000..0e9052e7d
--- /dev/null
+++ b/lbrynet/schema/schema/claim.py
@@ -0,0 +1,51 @@
+from copy import deepcopy
+
+from lbrynet.schema.proto import claim_pb2 as claim_pb
+from lbrynet.schema.schema import VERSION_MAP
+from lbrynet.schema.schema.signature import Signature
+from lbrynet.schema.schema.certificate import Certificate
+from lbrynet.schema.schema.schema import Schema
+from lbrynet.schema.schema.stream import Stream
+
+
+class Claim(Schema):
+    CLAIM_TYPE_STREAM = 1
+    CLAIM_TYPE_CERT = 2
+
+    @classmethod
+    def load(cls, message):
+        _claim = deepcopy(message)
+        _message_pb = claim_pb.Claim()
+        _message_pb.version = VERSION_MAP[_claim.pop("version")]
+
+        if "certificate" in _claim:
+            _cert = _claim.pop("certificate")
+            if isinstance(_cert, dict):
+                cert = Certificate.load(_cert)
+            else:
+                cert = _cert
+            claim_type = Claim.CLAIM_TYPE_CERT
+            _message_pb.certificate.MergeFrom(cert)
+
+        elif "stream" in _claim:
+            _stream = _claim.pop("stream")
+            if isinstance(_stream, dict):
+                stream = Stream.load(_stream)
+            else:
+                stream = _stream
+            claim_type = Claim.CLAIM_TYPE_STREAM
+            _message_pb.stream.MergeFrom(stream)
+        else:
+            raise AttributeError
+
+        _message_pb.claimType = claim_type
+
+        if "publisherSignature" in _claim:
+            _publisherSignature = _claim.pop("publisherSignature")
+            if isinstance(_publisherSignature, dict):
+                publisherSignature = Signature.load(_publisherSignature)
+            else:
+                publisherSignature = _publisherSignature
+            _message_pb.publisherSignature.MergeFrom(publisherSignature)
+
+        return cls._load(_claim, _message_pb)
diff --git a/lbrynet/schema/schema/fee.py b/lbrynet/schema/schema/fee.py
new file mode 100644
index 000000000..f91389455
--- /dev/null
+++ b/lbrynet/schema/schema/fee.py
@@ -0,0 +1,17 @@
+from copy import deepcopy
+
+from lbrynet.schema.schema.schema import Schema
+from lbrynet.schema.proto import fee_pb2 as fee_pb
+from lbrynet.schema.schema import VERSION_MAP, CURRENCY_MAP
+
+
+class Fee(Schema):
+    @classmethod
+    def load(cls, message):
+        _fee = deepcopy(message)
+        currency = CURRENCY_MAP[_fee.pop('currency')]
+        _message_pb = fee_pb.Fee()
+        _message_pb.version = VERSION_MAP[_fee.pop("version")]
+        _message_pb.currency = currency
+        _message_pb.address = _fee.pop('address')
+        return cls._load(_fee, _message_pb)
diff --git a/lbrynet/schema/schema/metadata.py b/lbrynet/schema/schema/metadata.py
new file mode 100644
index 000000000..edbf298a9
--- /dev/null
+++ b/lbrynet/schema/schema/metadata.py
@@ -0,0 +1,17 @@
+from copy import deepcopy
+from lbrynet.schema.proto import metadata_pb2 as metadata_pb
+from lbrynet.schema.schema.fee import Fee
+from lbrynet.schema.schema.schema import Schema
+from lbrynet.schema.schema import VERSION_MAP
+
+
+class Metadata(Schema):
+    @classmethod
+    def load(cls, message):
+        _metadata = deepcopy(message)
+        _message_pb = metadata_pb.Metadata()
+        _message_pb.version = VERSION_MAP[_metadata.pop("version")]
+        if 'fee' in _metadata:
+            fee_pb = Fee.load(_metadata.pop('fee'))
+            _message_pb.fee.CopyFrom(fee_pb)
+        return cls._load(_metadata, _message_pb)
diff --git a/lbrynet/schema/schema/schema.py b/lbrynet/schema/schema/schema.py
new file mode 100644
index 000000000..b6eb857cb
--- /dev/null
+++ b/lbrynet/schema/schema/schema.py
@@ -0,0 +1,15 @@
+import json
+import google.protobuf.json_format as json_pb  # pylint: disable=no-name-in-module
+from google.protobuf.message import Message  # pylint: disable=no-name-in-module,import-error
+
+
+class Schema(Message):
+    @classmethod
+    def load(cls, message):
+        raise NotImplementedError
+
+    @classmethod
+    def _load(cls, data, message):
+        if isinstance(data, dict):
+            data = json.dumps(data)
+        return json_pb.Parse(data, message)
diff --git a/lbrynet/schema/schema/signature.py b/lbrynet/schema/schema/signature.py
new file mode 100644
index 000000000..90190a142
--- /dev/null
+++ b/lbrynet/schema/schema/signature.py
@@ -0,0 +1,17 @@
+from copy import deepcopy
+
+from lbrynet.schema.proto import signature_pb2 as signature_pb
+from lbrynet.schema.schema import VERSION_MAP, ECDSA_CURVES
+from lbrynet.schema.schema.schema import Schema
+
+
+class Signature(Schema):
+    @classmethod
+    def load(cls, message):
+        _signature = deepcopy(message)
+        _message_pb = signature_pb.Signature()
+        _message_pb.version = VERSION_MAP[_signature.pop("version")]
+        _message_pb.signatureType = ECDSA_CURVES[_signature.pop("signatureType")]
+        _message_pb.certificateId = _signature.pop("certificateId")
+        _message_pb.signature = _signature.pop("signature")
+        return cls._load(_signature, _message_pb)
diff --git a/lbrynet/schema/schema/source.py b/lbrynet/schema/schema/source.py
new file mode 100644
index 000000000..0b90b4eab
--- /dev/null
+++ b/lbrynet/schema/schema/source.py
@@ -0,0 +1,19 @@
+from copy import deepcopy
+from lbrynet.schema.proto import source_pb2 as source_pb
+from lbrynet.schema.schema import SOURCE_TYPES, LBRY_SD_HASH_LENGTH, VERSION_MAP
+from lbrynet.schema.schema.schema import Schema
+from lbrynet.schema.error import InvalidSourceHashLength
+
+
+class Source(Schema):
+    @classmethod
+    def load(cls, message):
+        _source = deepcopy(message)
+        sd_hash = _source.pop('source')
+        assert len(sd_hash) == LBRY_SD_HASH_LENGTH, InvalidSourceHashLength(len(sd_hash))
+        _message_pb = source_pb.Source()
+        _message_pb.version = VERSION_MAP[_source.pop("version")]
+        _message_pb.sourceType = SOURCE_TYPES[_source.pop('sourceType')]
+        _message_pb.source = sd_hash
+        _message_pb.contentType = _source.pop('contentType')
+        return cls._load(_source, _message_pb)
diff --git a/lbrynet/schema/schema/stream.py b/lbrynet/schema/schema/stream.py
new file mode 100644
index 000000000..2fe955c4b
--- /dev/null
+++ b/lbrynet/schema/schema/stream.py
@@ -0,0 +1,20 @@
+from copy import deepcopy
+
+from lbrynet.schema.schema.source import Source
+from lbrynet.schema.proto import stream_pb2 as stream_pb
+from lbrynet.schema.schema import VERSION_MAP
+from lbrynet.schema.schema.metadata import Metadata
+from lbrynet.schema.schema.schema import Schema
+
+
+class Stream(Schema):
+    @classmethod
+    def load(cls, message):
+        _claim = deepcopy(message)
+        source = Source.load(_claim.pop('source'))
+        metadata = Metadata.load(_claim.pop('metadata'))
+        _message_pb = stream_pb.Stream()
+        _message_pb.version = VERSION_MAP[_claim.pop("version")]
+        _message_pb.source.CopyFrom(source)
+        _message_pb.metadata.CopyFrom(metadata)
+        return cls._load(_claim, _message_pb)
diff --git a/lbrynet/schema/signer.py b/lbrynet/schema/signer.py
new file mode 100644
index 000000000..4132c70c1
--- /dev/null
+++ b/lbrynet/schema/signer.py
@@ -0,0 +1,102 @@
+import ecdsa
+import hashlib
+import binascii
+from lbrynet.schema.address import decode_address
+from lbrynet.schema.encoding import decode_b64_fields
+from lbrynet.schema.schema.certificate import Certificate
+from lbrynet.schema.schema.claim import Claim
+from lbrynet.schema.validator import validate_claim_id
+from lbrynet.schema.schema import V_0_0_1, CLAIM_TYPE, CLAIM_TYPES, CERTIFICATE_TYPE, VERSION
+from lbrynet.schema.schema import NIST256p, NIST384p, SECP256k1, SHA256, SHA384
+
+
+class NIST_ECDSASigner(object):
+    CURVE = None
+    CURVE_NAME = None
+    HASHFUNC = hashlib.sha256
+    HASHFUNC_NAME = SHA256
+
+    def __init__(self, private_key):
+        self._private_key = private_key
+
+    @property
+    def private_key(self):
+        return self._private_key
+
+    @property
+    def public_key(self):
+        return self.private_key.get_verifying_key()
+
+    @property
+    def certificate(self):
+        certificate_claim = {
+            VERSION: V_0_0_1,
+            CLAIM_TYPE: CERTIFICATE_TYPE,
+            CLAIM_TYPES[CERTIFICATE_TYPE]: Certificate.load_from_key_obj(self.public_key,
+                                                                         self.CURVE_NAME)
+        }
+        return Claim.load(certificate_claim)
+
+    @classmethod
+    def load_pem(cls, pem_string):
+        return cls(ecdsa.SigningKey.from_pem(pem_string, hashfunc=cls.HASHFUNC_NAME))
+
+    @classmethod
+    def generate(cls):
+        return cls(ecdsa.SigningKey.generate(curve=cls.CURVE, hashfunc=cls.HASHFUNC_NAME))
+
+    def sign_stream_claim(self, claim, claim_address, cert_claim_id):
+        validate_claim_id(cert_claim_id)
+        decoded_addr = decode_address(claim_address)
+
+        to_sign = bytearray()
+        to_sign.extend(decoded_addr)
+        to_sign.extend(claim.serialized_no_signature)
+        to_sign.extend(binascii.unhexlify(cert_claim_id))
+
+        digest = self.HASHFUNC(to_sign).digest()
+
+        if not isinstance(self.private_key, ecdsa.SigningKey):
+            raise Exception("Not given a signing key")
+        sig_dict = {
+            "version": V_0_0_1,
+            "signatureType": self.CURVE_NAME,
+            "signature": self.private_key.sign_digest_deterministic(digest, hashfunc=self.HASHFUNC),
+            "certificateId": binascii.unhexlify(cert_claim_id)
+        }
+
+        msg = {
+            "version": V_0_0_1,
+            "stream": decode_b64_fields(claim.protobuf_dict)['stream'],
+            "publisherSignature": sig_dict
+        }
+
+        return Claim.load(msg)
+
+
+class NIST256pSigner(NIST_ECDSASigner):
+    CURVE = ecdsa.NIST256p
+    CURVE_NAME = NIST256p
+
+
+class NIST384pSigner(NIST_ECDSASigner):
+    CURVE = ecdsa.NIST384p
+    CURVE_NAME = NIST384p
+    HASHFUNC = hashlib.sha384
+    HASHFUNC_NAME = SHA384
+
+
+class SECP256k1Signer(NIST_ECDSASigner):
+    CURVE = ecdsa.SECP256k1
+    CURVE_NAME = SECP256k1
+
+
+def get_signer(curve):
+    if curve == NIST256p:
+        return NIST256pSigner
+    elif curve == NIST384p:
+        return NIST384pSigner
+    elif curve == SECP256k1:
+        return SECP256k1Signer
+    else:
+        raise Exception("Unknown curve: %s" % str(curve))
diff --git a/lbrynet/schema/uri.py b/lbrynet/schema/uri.py
new file mode 100644
index 000000000..cc9596bee
--- /dev/null
+++ b/lbrynet/schema/uri.py
@@ -0,0 +1,171 @@
+import re
+from lbrynet.schema.error import URIParseError
+
+PROTOCOL = 'lbry://'
+CHANNEL_CHAR = '@'
+CLAIM_ID_CHAR = '#'
+CLAIM_SEQUENCE_CHAR = ':'
+BID_POSITION_CHAR = '$'
+PATH_CHAR = '/'
+QUERY_CHAR = '?'
+
+CLAIM_ID_MAX_LENGTH = 40
+CHANNEL_NAME_MIN_LENGTH = 1
+
+
+class URI(object):
+    __slots__ = ['name', 'claim_sequence', 'bid_position', 'claim_id', 'path']
+
+    def __init__(self, name, claim_sequence=None, bid_position=None, claim_id=None, path=None):
+        if len([v for v in [claim_sequence, bid_position, claim_id] if v is not None]) > 1:
+            raise ValueError(
+                "Only one of these may be present at a time: claim_sequence, bid_position, claim_id"
+            )
+
+        self.name = name
+        self.claim_sequence = claim_sequence
+        self.bid_position = bid_position
+        self.claim_id = claim_id
+        self.path = path
+
+        if self.path is not None and not self.is_channel:
+            raise ValueError("Content claims cannot have paths")
+
+    def __str__(self):
+        return self.to_uri_string()
+
+    def __eq__(self, other):
+        for prop in self.__slots__:
+            if not hasattr(other, prop) or getattr(self, prop) != getattr(other, prop):
+                return False
+        return self.__class__ == other.__class__
+
+    @property
+    def is_channel(self):
+        return self.name.startswith(CHANNEL_CHAR)
+
+    def to_uri_string(self):
+        uri_string = PROTOCOL + "%s" % self.name
+
+        if self.claim_sequence is not None:
+            uri_string += CLAIM_SEQUENCE_CHAR + "%i" % self.claim_sequence
+        elif self.bid_position is not None:
+            uri_string += BID_POSITION_CHAR + "%i" % self.bid_position
+        elif self.claim_id is not None:
+            uri_string += CLAIM_ID_CHAR + "%s" % self.claim_id
+
+        if self.path is not None:
+            uri_string += PATH_CHAR + "%s" % self.path
+
+        return uri_string
+
+    def to_dict(self):
+        return {
+            "name": self.name,
+            'claim_sequence': self.claim_sequence,
+            'bid_position': self.bid_position,
+            'claim_id': self.claim_id,
+            'path': self.path,
+        }
+
+    @classmethod
+    def from_uri_string(cls, uri_string):
+        """
+        Parses LBRY uri into its components
+
+        :param uri_string: format - lbry://name:n$rank#id/path
+                           optional modifiers:
+                           claim_sequence (int): the nth claim to the name
+                           bid_position (int): the bid queue position of the claim for the name
+                           claim_id (str): the claim id for the claim
+                           path (str): claim within a channel
+        :return: URI
+        """
+        match = re.match(get_schema_regex(), uri_string)
+
+        if match is None:
+            raise URIParseError('Invalid URI')
+
+        if match.group('content_name') and match.group('path'):
+            raise URIParseError('Only channels may have paths')
+
+        return cls(
+            name=match.group("content_or_channel_name"),
+            claim_sequence=int(match.group("claim_sequence")) if match.group(
+                "claim_sequence") is not None else None,
+            bid_position=int(match.group("bid_position")) if match.group(
+                "bid_position") is not None else None,
+            claim_id=match.group("claim_id"),
+            path=match.group("path")
+        )
+
+    @classmethod
+    def from_dict(cls, uri_dict):
+        """
+        Creates URI from dict
+
+        :return: URI
+        """
+        return cls(**uri_dict)
+
+
+def get_schema_regex():
+    def _named(name, regex):
+        return "(?P<" + name + ">" + regex + ")"
+
+    def _group(regex):
+        return "(?:" + regex + ")"
+
+    # TODO: regex should include the fact that content names cannot have paths
+    #       right now this is only enforced in code, not in the regex
+
+    # Escape constants
+    claim_id_char = re.escape(CLAIM_ID_CHAR)
+    claim_sequence_char = re.escape(CLAIM_SEQUENCE_CHAR)
+    bid_position_char = re.escape(BID_POSITION_CHAR)
+    channel_char = re.escape(CHANNEL_CHAR)
+    path_char = re.escape(PATH_CHAR)
+    protocol = _named("protocol", re.escape(PROTOCOL))
+
+    # Define basic building blocks
+    valid_name_char = "[a-zA-Z0-9\-]"  # these characters are the only valid name characters
+    name_content = valid_name_char + '+'
+    name_min_channel_length = valid_name_char + '{' + str(CHANNEL_NAME_MIN_LENGTH) + ',}'
+
+    positive_number = "[1-9][0-9]*"
+    number = '\-?' + positive_number
+
+    # Define URI components
+    content_name = _named("content_name", name_content)
+    channel_name = _named("channel_name", channel_char + name_min_channel_length)
+    content_or_channel_name = _named("content_or_channel_name", content_name + "|" + channel_name)
+
+    claim_id_piece = _named("claim_id", "[0-9a-f]{1," + str(CLAIM_ID_MAX_LENGTH) + "}")
+    claim_id = _group(claim_id_char + claim_id_piece)
+
+    bid_position_piece = _named("bid_position", number)
+    bid_position = _group(bid_position_char + bid_position_piece)
+
+    claim_sequence_piece = _named("claim_sequence", number)
+    claim_sequence = _group(claim_sequence_char + claim_sequence_piece)
+
+    modifier = _named("modifier", claim_id + "|" + bid_position + "|" + claim_sequence)
+
+    path_piece = _named("path", name_content)
+    path = _group(path_char + path_piece)
+
+    # Combine components
+    uri = _named("uri", (
+        '^' +
+        protocol + '?' +
+        content_or_channel_name +
+        modifier + '?' +
+        path + '?' +
+        '$'
+    ))
+
+    return uri
+
+
+def parse_lbry_uri(lbry_uri):
+    return URI.from_uri_string(lbry_uri)
diff --git a/lbrynet/schema/validator.py b/lbrynet/schema/validator.py
new file mode 100644
index 000000000..77b01fca4
--- /dev/null
+++ b/lbrynet/schema/validator.py
@@ -0,0 +1,135 @@
+from string import hexdigits
+import ecdsa
+import hashlib
+import binascii
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.serialization import load_der_public_key
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.utils import Prehashed
+from cryptography.exceptions import InvalidSignature
+from ecdsa.util import sigencode_der
+
+from lbrynet.schema.address import decode_address
+from lbrynet.schema.schema import NIST256p, NIST384p, SECP256k1, ECDSA_CURVES, CURVE_NAMES
+
+
+def validate_claim_id(claim_id):
+    if not len(claim_id) == 40:
+        raise Exception("Incorrect claimid length: %i" % len(claim_id))
+    if isinstance(claim_id, bytes):
+        claim_id = claim_id.decode('utf-8')
+    if set(claim_id).difference(hexdigits):
+        raise Exception("Claim id is not hex encoded")
+
+
+class Validator:
+    CURVE_NAME = None
+    HASHFUNC = hashlib.sha256
+
+    def __init__(self, public_key, certificate_claim_id):
+        validate_claim_id(certificate_claim_id)
+        if CURVE_NAMES.get(get_key_type_from_dem(public_key)) != self.CURVE_NAME:
+            raise Exception("Curve mismatch")
+        self._public_key = public_key
+        self._certificate_claim_id = certificate_claim_id
+
+    @property
+    def public_key(self):
+        return self._public_key
+
+    @property
+    def certificate_claim_id(self):
+        return self._certificate_claim_id
+
+    @classmethod
+    def signing_key_from_pem(cls, pem):
+        return ecdsa.SigningKey.from_pem(pem, hashfunc=cls.HASHFUNC)
+
+    @classmethod
+    def signing_key_from_der(cls, der):
+        return ecdsa.SigningKey.from_der(der, hashfunc=cls.HASHFUNC)
+
+    @classmethod
+    def load_from_certificate(cls, certificate_claim, certificate_claim_id):
+        certificate = certificate_claim.certificate
+        return cls(certificate.publicKey, certificate_claim_id)
+
+    def validate_signature(self, digest, signature):
+        public_key = load_der_public_key(self.public_key, default_backend())
+        if len(signature) == 64:
+            hash = hashes.SHA256()
+        elif len(signature) == 96:
+            hash = hashes.SHA384()
+        signature = binascii.hexlify(signature)
+        r = int(signature[:int(len(signature)/2)], 16)
+        s = int(signature[int(len(signature)/2):], 16)
+        encoded_sig = sigencode_der(r, s, len(signature)*4)
+        try:
+            public_key.verify(encoded_sig, digest, ec.ECDSA(Prehashed(hash)))
+            return True
+        except InvalidSignature:
+            # TODO Fixme. This is what is expected today on the outer calls. This should be implementation independent
+            # but requires changing everything calling that
+            from ecdsa import BadSignatureError
+            raise BadSignatureError
+
+    def validate_claim_signature(self, claim, claim_address):
+        decoded_address = decode_address(claim_address)
+
+        # extract and serialize the stream from the claim, then check the signature
+        signature = binascii.unhexlify(claim.signature)
+
+        if signature is None:
+            raise Exception("No signature to validate")
+
+        to_sign = bytearray()
+        to_sign.extend(decoded_address)
+        to_sign.extend(claim.serialized_no_signature)
+        to_sign.extend(binascii.unhexlify(self.certificate_claim_id))
+
+        return self.validate_signature(self.HASHFUNC(to_sign).digest(), signature)
+
+    def validate_private_key(self, private_key):
+        if not isinstance(private_key, ecdsa.SigningKey):
+            raise TypeError("Not given a signing key, given a %s" % str(type(private_key)))
+        return private_key.get_verifying_key().to_der() == self.public_key
+
+
+class NIST256pValidator(Validator):
+    CURVE_NAME = NIST256p
+    HASHFUNC = hashlib.sha256
+
+
+class NIST384pValidator(Validator):
+    CURVE_NAME = NIST384p
+    HASHFUNC = hashlib.sha384
+
+
+class SECP256k1Validator(Validator):
+    CURVE_NAME = SECP256k1
+    HASHFUNC = hashlib.sha256
+
+
+def get_validator(curve):
+    if curve == NIST256p:
+        return NIST256pValidator
+    elif curve == NIST384p:
+        return NIST384pValidator
+    elif curve == SECP256k1:
+        return SECP256k1Validator
+    else:
+        raise Exception("Unknown curve: %s" % str(curve))
+
+
+def get_key_type_from_dem(pubkey_dem):
+    name = serialization.load_der_public_key(pubkey_dem, default_backend()).curve.name
+    if name == 'secp256k1':
+        return ECDSA_CURVES[SECP256k1]
+    elif name == 'secp256r1':
+        return ECDSA_CURVES[NIST256p]
+    elif name == 'secp384r1':
+        return ECDSA_CURVES[NIST384p]
+    raise Exception("unexpected curve: %s" % name)
diff --git a/lbrynet/core/utils.py b/lbrynet/utils.py
similarity index 89%
rename from lbrynet/core/utils.py
rename to lbrynet/utils.py
index db4f430d2..7955a4219 100644
--- a/lbrynet/core/utils.py
+++ b/lbrynet/utils.py
@@ -11,14 +11,11 @@ import logging
 import pkg_resources
 from twisted.python.failure import Failure
 from twisted.internet import defer
-from lbryschema.claim import ClaimDict
-from lbrynet.core.cryptoutils import get_lbry_hash_obj
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.cryptoutils import get_lbry_hash_obj
 
 log = logging.getLogger(__name__)
 
-# digest_size is in bytes, and blob hashes are hex encoded
-blobhash_length = get_lbry_hash_obj().digest_size * 2
-
 
 # defining these time functions here allows for easier overriding in testing
 def now():
@@ -52,6 +49,7 @@ def call_later(delay, func, *args, **kwargs):
     from twisted.internet import reactor
     return reactor.callLater(delay, func, *args, **kwargs)
 
+
 def safe_start_looping_call(looping_call, interval_sec):
     if not looping_call.running:
         looping_call.start(interval_sec)
@@ -69,21 +67,6 @@ def generate_id(num=None):
     return h.digest()
 
 
-def is_valid_hashcharacter(char):
-    return char in "0123456789abcdef"
-
-
-def is_valid_blobhash(blobhash):
-    """Checks whether the blobhash is the correct length and contains only
-    valid characters (0-9, a-f)
-
-    @param blobhash: string, the blobhash to check
-
-    @return: True/False
-    """
-    return len(blobhash) == blobhash_length and all(is_valid_hashcharacter(l) for l in blobhash)
-
-
 def version_is_greater_than(a, b):
     """Returns True if version a is more recent than version b"""
     return pkg_resources.parse_version(a) > pkg_resources.parse_version(b)
@@ -218,15 +201,12 @@ class DeferredProfiler:
             from twisted.internet import reactor
 
         def _cb(result, fn, start, caller_info):
-            if isinstance(result, (Failure, Exception)):
-                error = result
-                result = None
+            got_error = isinstance(result, (Failure, Exception))
+            self.add_result(fn, start, reactor.seconds(), caller_info, not got_error)
+            if got_error:
+                raise result
             else:
-                error = None
-            self.add_result(fn, start, reactor.seconds(), caller_info, error is None)
-            if error is None:
                 return result
-            raise error
 
         def _profiled_deferred(fn):
             reactor.addSystemEventTrigger("after", "shutdown", self.show_profile_results, fn)
diff --git a/lbrynet/wallet/__init__.py b/lbrynet/wallet/__init__.py
deleted file mode 100644
index 5ed03cc18..000000000
--- a/lbrynet/wallet/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-__node_daemon__ = 'lbrycrdd'
-__node_cli__ = 'lbrycrd-cli'
-__node_bin__ = ''
-__node_url__ = (
-    'https://github.com/lbryio/lbrycrd/releases/download/v0.12.2.1/lbrycrd-linux.zip'
-)
-__electrumx__ = 'lbryumx.coin.LBCRegTest'
-
-from .ledger import MainNetLedger, RegTestLedger
diff --git a/lbrynet/wallet/dewies.py b/lbrynet/wallet/dewies.py
deleted file mode 100644
index 20bfddecf..000000000
--- a/lbrynet/wallet/dewies.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import re
-import textwrap
-from torba.constants import COIN
-
-
-def lbc_to_dewies(lbc):
-    if isinstance(lbc, str):
-        result = re.search(r'^(\d{1,10})\.(\d{1,8})$', lbc)
-        if result is not None:
-            whole, fractional = result.groups()
-            return int(whole+fractional.ljust(8, "0"))
-    raise ValueError(textwrap.dedent(
-        """
-        Decimal inputs require a value in the ones place and in the tenths place
-        separated by a period. The value provided, '{}', is not of the correct
-        format.
-
-        The following are examples of valid decimal inputs:
-
-        1.0
-        0.001
-        2.34500
-        4534.4
-        2323434.0000
-
-        The following are NOT valid:
-
-        83
-        .456
-        123.
-        """.format(lbc)
-    ))
-
-
-def dewies_to_lbc(dewies):
-    lbc = '{:.8f}'.format(dewies / COIN).rstrip('0')
-    if lbc.endswith('.'):
-        return lbc+'0'
-    else:
-        return lbc
diff --git a/lbrynet/winhelpers/knownpaths-LICENSE.txt b/lbrynet/winhelpers/knownpaths-LICENSE.txt
deleted file mode 100644
index 5f9023892..000000000
--- a/lbrynet/winhelpers/knownpaths-LICENSE.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
- 
-Copyright (c) 2014 Michael Kropat
- 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
- 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
- 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/lbrynet/winhelpers/knownpaths.py b/lbrynet/winpaths.py
similarity index 98%
rename from lbrynet/winhelpers/knownpaths.py
rename to lbrynet/winpaths.py
index ebb68a393..96cd2b2c2 100644
--- a/lbrynet/winhelpers/knownpaths.py
+++ b/lbrynet/winpaths.py
@@ -1,4 +1,5 @@
-from __future__ import print_function
+# Copyright (c) 2014 Michael Kropat
+
 import sys
 import ctypes
 from ctypes import windll, wintypes
@@ -156,7 +157,7 @@ def get_path(folderid, user_handle=UserHandle.common):
 
 if __name__ == '__main__':
     if len(sys.argv) < 2 or sys.argv[1] in ['-?', '/?']:
-        print('python knownpaths.py FOLDERID {current|common}')
+        print('python winpaths.py FOLDERID {current|common}')
         sys.exit(0)
 
     try:
diff --git a/mkdocs.yml b/mkdocs.yml
index f5aa95d53..ccaf8a094 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -21,3 +21,9 @@ theme:
       link: 'https://twitter.com/lbryio'
     - type: 'facebook'
       link: 'https://facebook.com/lbryio'
+    - type: 'telegram'
+      link: 'https://t.me/lbryofficial'
+    - type: 'discord'
+      link: 'https://chat.lbry.io'
+    - type: 'reddit'
+      link: 'https://reddit.com/r/lbry'
diff --git a/scripts/docker_pyinstaller/Dockerfile b/scripts/docker_pyinstaller/Dockerfile
new file mode 100644
index 000000000..e79d72249
--- /dev/null
+++ b/scripts/docker_pyinstaller/Dockerfile
@@ -0,0 +1,87 @@
+FROM 32bit/ubuntu:16.04
+
+ENV DEBIAN_FRONTEND noninteractive
+
+#ARG WINE_VERSION=winehq-staging
+COPY wine_3.20.1-1_i386.deb /wine_3.20.1-1_i386.deb
+
+ARG PYTHON_VERSION=3.7.1
+ARG PYINSTALLER_VERSION=3.4
+
+# we need wine for this all to work, so we'll use the PPA
+RUN set -x \
+##    && dpkg --add-architecture i386 \
+    && dpkg -i /wine_3.20.1-1_i386.deb \
+    && apt-get update -qy \
+    && apt-get install --no-install-recommends -qfy apt-transport-https software-properties-common wget \
+    && wget -nv https://dl.winehq.org/wine-builds/Release.key \
+    && apt-key add Release.key \
+    && add-apt-repository 'https://dl.winehq.org/wine-builds/ubuntu/' \
+    && apt-get update -qy \
+#    && apt-get install --no-install-recommends -qfy $WINE_VERSION winbind cabextract \
+    && apt-get install --no-install-recommends -qfy winbind cabextract \
+    && apt-get clean \
+    && wget -nv https://raw.githubusercontent.com/Winetricks/winetricks/master/src/winetricks \
+    && chmod +x winetricks \
+    && mv winetricks /usr/local/bin
+
+# wine settings
+ENV WINEARCH win32
+ENV WINEDEBUG fixme-all
+ENV WINEPREFIX /wine
+
+# PYPI repository location
+ENV PYPI_URL=https://pypi.python.org/
+# PYPI index location
+ENV PYPI_INDEX_URL=https://pypi.python.org/simple
+
+# install python in wine, using the msi packages to install, extracting
+# the files directly, since installing isn't running correctly.
+RUN set -x \
+    && winetricks win7 \
+    && for msifile in `echo core dev exe lib path pip tcltk tools`; do \
+        wget -nv "https://www.python.org/ftp/python/$PYTHON_VERSION/win32/${msifile}.msi"; \
+        wine msiexec /i "${msifile}.msi" /qb TARGETDIR=C:/Python37; \
+        rm ${msifile}.msi; \
+    done \
+    && cd /wine/drive_c/Python37 \
+    && echo 'wine '\''C:\Python37\python.exe'\'' "$@"' > /usr/bin/python \
+    && echo 'wine '\''C:\Python37\Scripts\easy_install.exe'\'' "$@"' > /usr/bin/easy_install \
+    && echo 'wine '\''C:\Python37\Scripts\pip.exe'\'' "$@"' > /usr/bin/pip \
+    && echo 'wine '\''C:\Python37\Scripts\pyinstaller.exe'\'' "$@"' > /usr/bin/pyinstaller \
+    && echo 'wine '\''C:\Python37\Scripts\pyupdater.exe'\'' "$@"' > /usr/bin/pyupdater \
+    && echo 'assoc .py=PythonScript' | wine cmd \
+    && echo 'ftype PythonScript=c:\Python37\python.exe "%1" %*' | wine cmd \
+    && while pgrep wineserver >/dev/null; do echo "Waiting for wineserver"; sleep 1; done \
+    && chmod +x /usr/bin/python /usr/bin/easy_install /usr/bin/pip /usr/bin/pyinstaller /usr/bin/pyupdater \
+    && (pip install -U pip || true) \
+    && rm -rf /tmp/.wine-*
+
+ENV W_DRIVE_C=/wine/drive_c
+ENV W_WINDIR_UNIX="$W_DRIVE_C/windows"
+ENV W_SYSTEM_DLLS="$W_WINDIR_UNIX/system32"
+ENV W_TMP="$W_DRIVE_C/windows/temp/_$0"
+
+# install Microsoft Visual C++ Redistributable for Visual Studio 2017 dll files
+RUN set -x \
+    && rm -f "$W_TMP"/* \
+    && wget -P "$W_TMP" https://download.visualstudio.microsoft.com/download/pr/11687613/88b50ce70017bf10f2d56d60fcba6ab1/VC_redist.x86.exe \
+    && cabextract -q --directory="$W_TMP" "$W_TMP"/VC_redist.x86.exe \
+    && cabextract -q --directory="$W_TMP" "$W_TMP/a10" \
+    && cabextract -q --directory="$W_TMP" "$W_TMP/a11" \
+    && cd "$W_TMP" \
+    && rename 's/_/\-/g' *.dll \
+    && cp "$W_TMP"/*.dll "$W_SYSTEM_DLLS"/
+
+# put the src folder inside wine
+RUN mkdir /src/ && ln -s /src /wine/drive_c/src
+VOLUME /src/
+WORKDIR /wine/drive_c/src/
+RUN mkdir -p /wine/drive_c/tmp
+
+RUN pip install pyinstaller==$PYINSTALLER_VERSION
+
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+ENTRYPOINT ["/entrypoint.sh"]
diff --git a/scripts/docker_pyinstaller/README.md b/scripts/docker_pyinstaller/README.md
new file mode 100644
index 000000000..2e8bb3553
--- /dev/null
+++ b/scripts/docker_pyinstaller/README.md
@@ -0,0 +1,7 @@
+# PyInstaller docker image fork used on build process
+
+This is a temporary fork of [docker-pyinstaller](https://github.com/cdrx/docker-pyinstaller/tree/master/win32/py3) that uses [zzhiyi's fork of wine](https://github.com/zzhiyi/wine/tree/kernelbase/PathCchCanonicalizeEx) to build with Python 3.7.1 and PyInstaller 3.4.
+Once those changes settles both in wine and docker-pyinstaller repo, this folder should be removed.
+
+## But hey, where is `wine_3.20.1-1_i386.deb` and how was it generated?
+It's a package generated out of above mentioned wine branch. You can find instructions on how to generate Debian packages on the [Wine Wiki](https://wiki.winehq.org/Building_Biarch_Wine_On_Ubuntu) or use a helper like [docker-wine-builder](https://github.com/shyba/docker-wine-builder).
diff --git a/scripts/docker_pyinstaller/entrypoint.sh b/scripts/docker_pyinstaller/entrypoint.sh
new file mode 100644
index 000000000..d12a3539a
--- /dev/null
+++ b/scripts/docker_pyinstaller/entrypoint.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Fail on errors.
+set -e
+
+#
+# In case the user specified a custom URL for PYPI, then use
+# that one, instead of the default one.
+#
+if [[ "$PYPI_URL" != "https://pypi.python.org/" ]] || \
+   [[ "$PYPI_INDEX_URL" != "https://pypi.python.org/simple" ]]; then
+    # the funky looking regexp just extracts the hostname, excluding port
+    # to be used as a trusted-host.
+    mkdir -p /wine/drive_c/users/root/pip
+    echo "[global]" > /wine/drive_c/users/root/pip/pip.ini
+    echo "index = $PYPI_URL" >> /wine/drive_c/users/root/pip/pip.ini
+    echo "index-url = $PYPI_INDEX_URL" >> /wine/drive_c/users/root/pip/pip.ini
+    echo "trusted-host = $(echo $PYPI_URL | perl -pe 's|^.*?://(.*?)(:.*?)?/.*$|$1|')" >> /wine/drive_c/users/root/pip/pip.ini
+
+    echo "Using custom pip.ini: "
+    cat /wine/drive_c/users/root/pip/pip.ini
+fi
+
+cd /src
+
+if [ -f requirements.txt ]; then
+    pip install -r requirements.txt
+fi # [ -f requirements.txt ]
+
+echo "$@"
+
+if [[ "$@" == "" ]]; then
+    pyinstaller --clean -y --dist ./dist/windows --workpath /tmp *.spec
+    chown -R --reference=. ./dist/windows
+else
+    sh -c "$@"
+fi # [[ "$@" == "" ]]
diff --git a/scripts/download_blob_from_peer.py b/scripts/download_blob_from_peer.py
index c9511a2ca..89d89df18 100644
--- a/scripts/download_blob_from_peer.py
+++ b/scripts/download_blob_from_peer.py
@@ -11,14 +11,14 @@ from twisted.internet import asyncioreactor
 asyncioreactor.install()
 from twisted.internet import defer, threads, reactor
 
-from lbrynet import conf
-from lbrynet.core import log_support, Peer
-from lbrynet.core.SinglePeerDownloader import SinglePeerDownloader
-from lbrynet.core.StreamDescriptor import BlobStreamDescriptorReader
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.daemon.Components import f2d
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.wallet.manager import LbryWalletManager
+from lbrynet import conf, log_support
+from lbrynet.p2p import Peer
+from lbrynet.p2p.SinglePeerDownloader import SinglePeerDownloader
+from lbrynet.p2p.StreamDescriptor import BlobStreamDescriptorReader
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.extras.daemon.Components import f2d
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.extras.wallet import LbryWalletManager
 
 log = logging.getLogger()
 
diff --git a/scripts/encrypt_blob.py b/scripts/encrypt_blob.py
index 2b83dce3e..3993ffaeb 100644
--- a/scripts/encrypt_blob.py
+++ b/scripts/encrypt_blob.py
@@ -9,7 +9,7 @@ from twisted.web.client import FileBodyProducer
 
 from lbrynet import conf
 from lbrynet.core import log_support
-from lbrynet.dht.hashannouncer import DummyHashAnnouncer
+from lbrynet.extras.daemon.HashAnnouncer import DHTHashAnnouncer
 from lbrynet.core.BlobManager import DiskBlobManager
 from lbrynet.cryptstream.CryptStreamCreator import CryptStreamCreator
 
diff --git a/scripts/wine_build.sh b/scripts/wine_build.sh
index e6c8130f6..5e303a3e8 100755
--- a/scripts/wine_build.sh
+++ b/scripts/wine_build.sh
@@ -5,18 +5,28 @@ rm -rf /tmp/.wine-*
 apt-get -qq update
 apt-get -qq install -y git
 
-git clone https://github.com/lbryio/lbryschema.git --depth 1
 git clone https://github.com/lbryio/torba.git --depth 1
+sed -i -e "s/'plyvel',//" torba/setup.py
 git clone https://github.com/twisted/twisted.git --depth 1 --branch twisted-18.7.0
 sed -i -e '172,184{s/^/#/}' twisted/src/twisted/python/_setup.py
 
 pip install setuptools_scm
 cd twisted && pip install -e .[tls] && cd ..
-cd lbryschema && pip install -e . && cd ..
 cd torba && pip install -e . && cd ..
 
 cd lbry
 python scripts/set_build.py
+
+# Download from their CI until its not released. Remove later!
+wget -Onetifaces-0.10.7-cp37-cp37m-win32.whl https://ci.appveyor.com/api/buildjobs/6hworunifsymrhp2/artifacts/dist%2Fnetifaces-0.10.7-cp37-cp37m-win32.whl
+pip install netifaces-0.10.7-cp37-cp37m-win32.whl
+
 pip install -e .
-pyinstaller --additional-hooks-dir=scripts/. -F -n lbrynet lbrynet/cli.py
+
+# Twisted needs that, but installing before lbry makes everything hang
+# PyInstaller removed that as a dependency in 3.4
+# The source file from Twisted that requires it is "src/twisted/internet/stdio.py"
+pip install pywin32
+
+pyinstaller --additional-hooks-dir=scripts/. -F -n lbrynet lbrynet/extras/cli.py
 wine dist/lbrynet.exe --version
diff --git a/setup.py b/setup.py
index d218099f1..c4bbb5323 100644
--- a/setup.py
+++ b/setup.py
@@ -20,7 +20,7 @@ setup(
     packages=find_packages(exclude=('tests',)),
     zip_safe=False,
     entry_points={
-        'console_scripts': 'lbrynet=lbrynet.cli:main'
+        'console_scripts': 'lbrynet=lbrynet.extras.cli:main'
     },
     install_requires=[
         'aiohttp',
@@ -32,7 +32,10 @@ setup(
         'envparse',
         'jsonrpc',
         'cryptography',
-        'lbryschema',
+        'protobuf==3.6.1',
+        'msgpack',
+        'jsonschema',
+        'ecdsa',
         'torba',
         'pyyaml',
         'requests',
@@ -40,13 +43,10 @@ setup(
         'treq',
         'docopt',
         'colorama==0.3.7',
-        'six'
     ],
     extras_require={
         'test': (
-            'mock>=2.0,<3.0',
             'faker==0.8.17',
-            'orchstr8>=0.0.4'
         )
     }
 )
diff --git a/tests/functional/dht/test_store.py b/tests/functional/dht/test_store.py
index e50e12fec..b45eef3d7 100644
--- a/tests/functional/dht/test_store.py
+++ b/tests/functional/dht/test_store.py
@@ -3,7 +3,7 @@ from binascii import hexlify
 
 from twisted.internet import defer
 from lbrynet.dht import constants
-from lbrynet.core.utils import generate_id
+from lbrynet.utils import generate_id
 from .dht_test_environment import TestKademliaBase
 import logging
 
diff --git a/tests/functional/test_misc.py b/tests/functional/test_misc.py
index eb2595537..606c2b372 100644
--- a/tests/functional/test_misc.py
+++ b/tests/functional/test_misc.py
@@ -3,22 +3,22 @@ from hashlib import md5
 from twisted.internet import defer, reactor
 from twisted.trial import unittest
 from lbrynet import conf
-from lbrynet.core.server.BlobAvailabilityHandler import BlobAvailabilityHandlerFactory
-from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier
-from lbrynet.core.StreamDescriptor import download_sd_blob
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.core.PeerManager import PeerManager
-from lbrynet.core.RateLimiter import RateLimiter
-from lbrynet.core.server.BlobRequestHandler import BlobRequestHandlerFactory
-from lbrynet.core.server.ServerProtocol import ServerProtocolFactory
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.file_manager.EncryptedFileCreator import create_lbry_file
-from lbrynet.file_manager.EncryptedFileManager import EncryptedFileManager
-from lbrynet.lbry_file.client.EncryptedFileOptions import add_lbry_file_to_sd_identifier
+from lbrynet.p2p.server.BlobAvailabilityHandler import BlobAvailabilityHandlerFactory
+from lbrynet.p2p.StreamDescriptor import StreamDescriptorIdentifier
+from lbrynet.p2p.StreamDescriptor import download_sd_blob
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.extras.daemon.PeerManager import PeerManager
+from lbrynet.p2p.RateLimiter import RateLimiter
+from lbrynet.p2p.server.BlobRequestHandler import BlobRequestHandlerFactory
+from lbrynet.p2p.server.ServerProtocol import ServerProtocolFactory
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.blob.EncryptedFileCreator import create_lbry_file
+from lbrynet.blob.EncryptedFileManager import EncryptedFileManager
+from lbrynet.blob.client.EncryptedFileOptions import add_lbry_file_to_sd_identifier
 
 from tests import mocks
-from tests.util import mk_db_and_blob_dir, rm_db_and_blob_dir
+from tests.test_utils import mk_db_and_blob_dir, rm_db_and_blob_dir
 
 FakeNode = mocks.Node
 FakeWallet = mocks.Wallet
diff --git a/tests/functional/test_reflector.py b/tests/functional/test_reflector.py
index ac2982a53..6c2ff7285 100644
--- a/tests/functional/test_reflector.py
+++ b/tests/functional/test_reflector.py
@@ -3,17 +3,20 @@ from binascii import hexlify
 
 from twisted.internet import defer, error
 from twisted.trial import unittest
-from lbrynet.core.StreamDescriptor import get_sd_info
-from lbrynet import reflector
-from lbrynet.core import BlobManager, PeerManager
-from lbrynet.core import StreamDescriptor
-from lbrynet.file_manager import EncryptedFileCreator
-from lbrynet.file_manager.EncryptedFileManager import EncryptedFileManager
-from lbrynet.core.RateLimiter import DummyRateLimiter
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
+from lbrynet.p2p.StreamDescriptor import get_sd_info
+from lbrynet.extras.reflector.server.server import ReflectorServerFactory
+from lbrynet.extras.reflector.client.client import EncryptedFileReflectorClientFactory
+from lbrynet.extras.reflector.client.blob import BlobReflectorClientFactory
+from lbrynet.extras.daemon.PeerManager import PeerManager
+from lbrynet.p2p import BlobManager
+from lbrynet.p2p import StreamDescriptor
+from lbrynet.blob import EncryptedFileCreator
+from lbrynet.blob.EncryptedFileManager import EncryptedFileManager
+from lbrynet.p2p.RateLimiter import DummyRateLimiter
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
 from tests import mocks
-from tests.util import mk_db_and_blob_dir, rm_db_and_blob_dir
+from tests.test_utils import mk_db_and_blob_dir, rm_db_and_blob_dir
 
 
 class TestReflector(unittest.TestCase):
@@ -25,7 +28,7 @@ class TestReflector(unittest.TestCase):
         self.client_db_dir, self.client_blob_dir = mk_db_and_blob_dir()
         prm = OnlyFreePaymentsManager()
         wallet = mocks.Wallet()
-        peer_manager = PeerManager.PeerManager()
+        peer_manager = PeerManager()
         peer_finder = mocks.PeerFinder(5553, peer_manager, 2)
         self.server_storage = SQLiteStorage(self.server_db_dir)
         self.server_blob_manager = BlobManager.DiskBlobManager(self.server_blob_dir, self.server_storage)
@@ -95,7 +98,7 @@ class TestReflector(unittest.TestCase):
             return d
 
         def start_server():
-            server_factory = reflector.ServerFactory(peer_manager, self.server_blob_manager,
+            server_factory = ReflectorServerFactory(peer_manager, self.server_blob_manager,
                                                      self.server_lbry_file_manager)
             from twisted.internet import reactor
             port = 8943
@@ -179,7 +182,7 @@ class TestReflector(unittest.TestCase):
             return d
 
         def send_to_server():
-            factory = reflector.ClientFactory(self.client_blob_manager, self.stream_hash, self.sd_hash)
+            factory = EncryptedFileReflectorClientFactory(self.client_blob_manager, self.stream_hash, self.sd_hash)
 
             from twisted.internet import reactor
             reactor.connectTCP('localhost', self.port, factory)
@@ -208,7 +211,7 @@ class TestReflector(unittest.TestCase):
             return d
 
         def send_to_server(blob_hashes_to_send):
-            factory = reflector.BlobClientFactory(
+            factory = BlobReflectorClientFactory(
                 self.client_blob_manager,
                 blob_hashes_to_send
             )
@@ -247,7 +250,7 @@ class TestReflector(unittest.TestCase):
             return d
 
         def send_to_server(blob_hashes_to_send):
-            factory = reflector.BlobClientFactory(
+            factory = BlobReflectorClientFactory(
                 self.client_blob_manager,
                 blob_hashes_to_send
             )
@@ -301,7 +304,7 @@ class TestReflector(unittest.TestCase):
             return d
 
         def send_to_server_as_blobs(blob_hashes_to_send):
-            factory = reflector.BlobClientFactory(
+            factory = BlobReflectorClientFactory(
                 self.client_blob_manager,
                 blob_hashes_to_send
             )
@@ -312,7 +315,7 @@ class TestReflector(unittest.TestCase):
             return factory.finished_deferred
 
         def send_to_server_as_stream(result):
-            factory = reflector.ClientFactory(self.client_blob_manager, self.stream_hash, self.sd_hash)
+            factory = EncryptedFileReflectorClientFactory(self.client_blob_manager, self.stream_hash, self.sd_hash)
 
             from twisted.internet import reactor
             reactor.connectTCP('localhost', self.port, factory)
diff --git a/tests/functional/test_streamify.py b/tests/functional/test_streamify.py
index 614aaff75..52008aeb9 100644
--- a/tests/functional/test_streamify.py
+++ b/tests/functional/test_streamify.py
@@ -4,15 +4,15 @@ import tempfile
 from hashlib import md5
 from twisted.trial.unittest import TestCase
 from twisted.internet import defer, threads
-from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.core.StreamDescriptor import get_sd_info
-from lbrynet.core.PeerManager import PeerManager
-from lbrynet.core.RateLimiter import DummyRateLimiter
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
-from lbrynet.file_manager.EncryptedFileCreator import create_lbry_file
-from lbrynet.file_manager.EncryptedFileManager import EncryptedFileManager
+from lbrynet.p2p.StreamDescriptor import StreamDescriptorIdentifier
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.p2p.StreamDescriptor import get_sd_info
+from lbrynet.p2p.RateLimiter import DummyRateLimiter
+from lbrynet.extras.daemon.PeerManager import PeerManager
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
+from lbrynet.blob.EncryptedFileCreator import create_lbry_file
+from lbrynet.blob.EncryptedFileManager import EncryptedFileManager
 from tests import mocks
 
 
diff --git a/tests/integration/cli/test_cli.py b/tests/integration/cli/test_cli.py
index 8b96537b6..d2861ec87 100644
--- a/tests/integration/cli/test_cli.py
+++ b/tests/integration/cli/test_cli.py
@@ -4,12 +4,12 @@ from io import StringIO
 from twisted.internet import defer
 
 from lbrynet import conf
-from lbrynet import cli
-from lbrynet.daemon.Components import DATABASE_COMPONENT, BLOB_COMPONENT, HEADERS_COMPONENT, WALLET_COMPONENT, \
-    DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT, STREAM_IDENTIFIER_COMPONENT, FILE_MANAGER_COMPONENT, \
+from lbrynet.extras import cli
+from lbrynet.extras.daemon.Components import DATABASE_COMPONENT, BLOB_COMPONENT, HEADERS_COMPONENT, WALLET_COMPONENT, \
+    DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT, FILE_MANAGER_COMPONENT, \
     PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, \
     RATE_LIMITER_COMPONENT, PAYMENT_RATE_COMPONENT
-from lbrynet.daemon.Daemon import Daemon
+from lbrynet.extras.daemon.Daemon import Daemon
 
 
 class FakeAnalytics:
@@ -35,7 +35,7 @@ class CLIIntegrationTest(unittest.TestCase):
     def setUp(self):
         skip = [
             DATABASE_COMPONENT, BLOB_COMPONENT, HEADERS_COMPONENT, WALLET_COMPONENT,
-            DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT, STREAM_IDENTIFIER_COMPONENT, FILE_MANAGER_COMPONENT,
+            DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT, FILE_MANAGER_COMPONENT,
             PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT,
             RATE_LIMITER_COMPONENT, PAYMENT_RATE_COMPONENT
         ]
diff --git a/tests/integration/wallet/test_commands.py b/tests/integration/wallet/test_commands.py
index 276cf2d34..f1414c59e 100644
--- a/tests/integration/wallet/test_commands.py
+++ b/tests/integration/wallet/test_commands.py
@@ -2,31 +2,31 @@ import json
 import asyncio
 import tempfile
 import logging
+from binascii import unhexlify
+from functools import partial
 from types import SimpleNamespace
 
 from twisted.trial import unittest
 from twisted.internet import utils, defer
 from twisted.internet.utils import runWithWarningsSuppressed as originalRunWith
+from lbrynet.p2p.Error import InsufficientFundsError
 
-from orchstr8.testcase import IntegrationTestCase as BaseIntegrationTestCase
+from torba.testcase import IntegrationTestCase as BaseIntegrationTestCase
 
-import lbryschema
-lbryschema.BLOCKCHAIN_NAME = 'lbrycrd_regtest'
+import lbrynet.schema
+lbrynet.schema.BLOCKCHAIN_NAME = 'lbrycrd_regtest'
 
 from lbrynet import conf as lbry_conf
 from lbrynet.dht.node import Node
-from lbrynet.daemon.Daemon import Daemon
-from lbrynet.wallet.manager import LbryWalletManager
-from lbrynet.daemon.Components import WalletComponent, DHTComponent, HashAnnouncerComponent, \
+from lbrynet.extras.daemon.Daemon import Daemon
+from lbrynet.extras.wallet import LbryWalletManager
+from lbrynet.extras.daemon.Components import WalletComponent, DHTComponent, HashAnnouncerComponent, \
     ExchangeRateManagerComponent
-from lbrynet.daemon.Components import REFLECTOR_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT
-from lbrynet.daemon.Components import UPnPComponent
-from lbrynet.daemon.Components import d2f
-from lbrynet.daemon.ComponentManager import ComponentManager
-from lbrynet.daemon.auth.server import jsonrpc_dumps_pretty
-
-
-log = logging.getLogger(__name__)
+from lbrynet.extras.daemon.Components import REFLECTOR_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT
+from lbrynet.extras.daemon.Components import UPnPComponent
+from lbrynet.extras.daemon.Components import d2f
+from lbrynet.extras.daemon.ComponentManager import ComponentManager
+from lbrynet.extras.daemon.auth.server import jsonrpc_dumps_pretty
 
 
 class FakeUPnP(UPnPComponent):
@@ -114,20 +114,19 @@ utils.runWithWarningsSuppressed = run_with_async_support
 class CommandTestCase(IntegrationTestCase):
 
     timeout = 180
-    WALLET_MANAGER = LbryWalletManager
+    MANAGER = LbryWalletManager
 
     async def setUp(self):
         await super().setUp()
 
-        if self.VERBOSE:
-            log.setLevel(logging.DEBUG)
-            logging.getLogger('lbrynet.core').setLevel(logging.DEBUG)
+        logging.getLogger('lbrynet.p2p').setLevel(self.VERBOSITY)
+        logging.getLogger('lbrynet.daemon').setLevel(self.VERBOSITY)
 
         lbry_conf.settings = None
         lbry_conf.initialize_settings(load_conf_file=False)
-        lbry_conf.settings['data_dir'] = self.stack.wallet.data_path
-        lbry_conf.settings['lbryum_wallet_dir'] = self.stack.wallet.data_path
-        lbry_conf.settings['download_directory'] = self.stack.wallet.data_path
+        lbry_conf.settings['data_dir'] = self.wallet_node.data_path
+        lbry_conf.settings['lbryum_wallet_dir'] = self.wallet_node.data_path
+        lbry_conf.settings['download_directory'] = self.wallet_node.data_path
         lbry_conf.settings['use_upnp'] = False
         lbry_conf.settings['reflect_uploads'] = False
         lbry_conf.settings['blockchain_name'] = 'lbrycrd_regtest'
@@ -175,6 +174,20 @@ class CommandTestCase(IntegrationTestCase):
         await self.generate(1)
         await self.on_transaction_id(txid)
 
+    async def on_transaction_dict(self, tx):
+        await self.ledger.wait(
+            self.ledger.transaction_class(unhexlify(tx['hex']))
+        )
+
+    @staticmethod
+    def get_all_addresses(tx):
+        addresses = set()
+        for txi in tx['inputs']:
+            addresses.add(txi['address'])
+        for txo in tx['outputs']:
+            addresses.add(txo['address'])
+        return list(addresses)
+
     async def generate(self, blocks):
         """ Ask lbrycrd to generate some blocks and wait until ledger has them. """
         await self.blockchain.generate(blocks)
@@ -187,7 +200,8 @@ class CommandTestCase(IntegrationTestCase):
 
 
 class EpicAdventuresOfChris45(CommandTestCase):
-    VERBOSE = False
+
+    VERBOSITY = logging.WARN
 
     async def test_no_this_is_not_a_test_its_an_adventure(self):
         # Chris45 is an avid user of LBRY and this is his story. It's fact and fiction
@@ -283,7 +297,7 @@ class EpicAdventuresOfChris45(CommandTestCase):
 
         # After some soul searching Chris decides that his story needs more
         # heart and a better ending. He takes down the story and begins the rewrite.
-        abandon = await self.out(self.daemon.jsonrpc_claim_abandon(claim1['claim_id']))
+        abandon = await self.out(self.daemon.jsonrpc_claim_abandon(claim1['claim_id'], blocking=False))
         self.assertTrue(abandon['success'])
         await self.confirm_tx(abandon['tx']['txid'])
 
@@ -398,7 +412,7 @@ class EpicAdventuresOfChris45(CommandTestCase):
 
         # But sadly Ramsey wasn't so pleased. It was hard for him to tell Chris...
         # Chris, though a bit heartbroken, abandoned the claim for now, but instantly started working on new hit lyrics
-        abandon = await self.out(self.daemon.jsonrpc_claim_abandon(txid=claim4['tx']['txid'], nout=0))
+        abandon = await self.out(self.daemon.jsonrpc_claim_abandon(txid=claim4['tx']['txid'], nout=0, blocking=False))
         self.assertTrue(abandon['success'])
         await self.confirm_tx(abandon['tx']['txid'])
 
@@ -464,9 +478,40 @@ class AccountManagement(CommandTestCase):
         self.assertEqual(response['name'], 'recreated account')
 
 
-class PublishCommand(CommandTestCase):
+class ClaimManagement(CommandTestCase):
 
-    VERBOSE = False
+    VERBOSITY = logging.WARN
+
+    async def make_claim(self, name='hovercraft', amount='1.0', data=b'hi!', channel_name=None):
+        with tempfile.NamedTemporaryFile() as file:
+            file.write(data)
+            file.flush()
+            claim = await self.out(self.daemon.jsonrpc_publish(
+                name, amount, file_path=file.name, channel_name=channel_name
+            ))
+            self.assertTrue(claim['success'])
+            await self.on_transaction_dict(claim['tx'])
+            await self.generate(1)
+            return claim
+
+    async def test_update_claim_holding_address(self):
+        other_account_id = (await self.daemon.jsonrpc_account_create('second account'))['id']
+        other_account = self.daemon.get_account_or_error(other_account_id)
+        other_address = await other_account.receiving.get_or_create_usable_address()
+
+        self.assertEqual('10.0', await self.daemon.jsonrpc_account_balance())
+
+        # create the initial name claim
+        claim = await self.make_claim()
+
+        self.assertEqual(len(await self.daemon.jsonrpc_claim_list_mine()), 1)
+        self.assertEqual(len(await self.daemon.jsonrpc_claim_list_mine(account_id=other_account_id)), 0)
+        tx = await self.daemon.jsonrpc_claim_send_to_address(
+            claim['claim_id'], other_address
+        )
+        await self.ledger.wait(tx)
+        self.assertEqual(len(await self.daemon.jsonrpc_claim_list_mine()), 0)
+        self.assertEqual(len(await self.daemon.jsonrpc_claim_list_mine(account_id=other_account_id)), 1)
 
     async def test_publishing_checks_all_accounts_for_certificate(self):
         account1_id, account1 = self.account.id, self.account
@@ -530,3 +575,132 @@ class PublishCommand(CommandTestCase):
                     'hovercraft', '1.0', file_path=file.name,
                     channel_name='@baz', channel_account_id=[account1_id]
                 ))
+
+    async def test_updating_claim_includes_claim_value_in_balance_check(self):
+        self.assertEqual('10.0', await self.daemon.jsonrpc_account_balance())
+
+        await self.make_claim(amount='9.0')
+        self.assertEqual('0.979893', await self.daemon.jsonrpc_account_balance())
+
+        # update the same claim
+        await self.make_claim(amount='9.0')
+        self.assertEqual('0.9796205', await self.daemon.jsonrpc_account_balance())
+
+        # update the claim a second time but use even more funds
+        await self.make_claim(amount='9.97')
+        self.assertEqual('0.009348', await self.daemon.jsonrpc_account_balance())
+
+        # fails when specifying more than available
+        with tempfile.NamedTemporaryFile() as file:
+            file.write(b'hi!')
+            file.flush()
+            with self.assertRaisesRegex(
+                InsufficientFundsError,
+                "Please lower the bid value, the maximum amount"
+                " you can specify for this claim is 9.979274."
+            ):
+                await self.out(self.daemon.jsonrpc_publish(
+                    'hovercraft', '9.98', file_path=file.name
+                ))
+
+    async def test_abandoning_claim_at_loss(self):
+        self.assertEqual('10.0', await self.daemon.jsonrpc_account_balance())
+        claim = await self.make_claim(amount='0.0001')
+        self.assertEqual('9.979793', await self.daemon.jsonrpc_account_balance())
+        await self.out(self.daemon.jsonrpc_claim_abandon(claim['claim_id']))
+        self.assertEqual('9.97968399', await self.daemon.jsonrpc_account_balance())
+
+    async def test_abandoned_channel_with_signed_claims(self):
+        channel = await self.out(self.daemon.jsonrpc_channel_new('@abc', "1.0"))
+        self.assertTrue(channel['success'])
+        await self.confirm_tx(channel['tx']['txid'])
+        claim = await self.make_claim(amount='0.0001', name='on-channel-claim', channel_name='@abc')
+        self.assertTrue(claim['success'])
+        abandon = await self.out(self.daemon.jsonrpc_claim_abandon(txid=channel['tx']['txid'], nout=0, blocking=False))
+        self.assertTrue(abandon['success'])
+        channel = await self.out(self.daemon.jsonrpc_channel_new('@abc', "1.0"))
+        self.assertTrue(channel['success'])
+        await self.confirm_tx(channel['tx']['txid'])
+
+        # Original channel doesnt exists anymore, so the signature is invalid. For invalid signatures, resolution is
+        # only possible outside a channel
+        response = await self.out(self.daemon.jsonrpc_resolve(uri='lbry://@abc/on-channel-claim'))
+        self.assertNotIn('claim', response['lbry://@abc/on-channel-claim'])
+        response = await self.out(self.daemon.jsonrpc_resolve(uri='lbry://on-channel-claim'))
+        self.assertIn('claim', response['lbry://on-channel-claim'])
+        self.assertFalse(response['lbry://on-channel-claim']['claim']['signature_is_valid'])
+        direct_uri = 'lbry://on-channel-claim#' + claim['claim_id']
+        response = await self.out(self.daemon.jsonrpc_resolve(uri=direct_uri))
+        self.assertIn('claim', response[direct_uri])
+        self.assertFalse(response[direct_uri]['claim']['signature_is_valid'])
+
+    async def test_regular_supports_and_tip_supports(self):
+        # account2 will be used to send tips and supports to account1
+        account2_id = (await self.daemon.jsonrpc_account_create('second account'))['id']
+
+        # send account2 5 LBC out of the 10 LBC in account1
+        result = await self.out(self.daemon.jsonrpc_wallet_send(
+            '5.0', await self.daemon.jsonrpc_address_unused(account2_id)
+        ))
+        await self.confirm_tx(result['txid'])
+
+        # account1 and account2 balances:
+        self.assertEqual('4.999876', await self.daemon.jsonrpc_account_balance())
+        self.assertEqual('5.0', await self.daemon.jsonrpc_account_balance(account2_id))
+
+        # create the claim we'll be tipping and supporting
+        claim = await self.make_claim()
+
+        # account1 and account2 balances:
+        self.assertEqual('3.979769', await self.daemon.jsonrpc_account_balance())
+        self.assertEqual('5.0', await self.daemon.jsonrpc_account_balance(account2_id))
+
+        # send a tip to the claim using account2
+        tip = await self.out(
+            self.daemon.jsonrpc_claim_tip(claim['claim_id'], '1.0', account2_id)
+        )
+        await self.on_transaction_dict(tip)
+        await self.generate(1)
+        await self.on_transaction_dict(tip)
+
+        # tips don't affect balance so account1 balance is same but account2 balance went down
+        self.assertEqual('3.979769', await self.daemon.jsonrpc_account_balance())
+        self.assertEqual('3.9998585', await self.daemon.jsonrpc_account_balance(account2_id))
+
+        # verify that the incoming tip is marked correctly as is_tip=True in account1
+        txs = await self.out(self.daemon.jsonrpc_transaction_list())
+        self.assertEqual(len(txs[0]['support_info']), 1)
+        self.assertEqual(txs[0]['support_info'][0]['balance_delta'], '1.0')
+        self.assertEqual(txs[0]['support_info'][0]['claim_id'], claim['claim_id'])
+        self.assertEqual(txs[0]['support_info'][0]['is_tip'], True)
+        self.assertEqual(txs[0]['value'], '1.0')
+
+        # verify that the outgoing tip is marked correctly as is_tip=True in account2
+        txs2 = await self.out(
+            self.daemon.jsonrpc_transaction_list(account2_id)
+        )
+        self.assertEqual(len(txs2[0]['support_info']), 1)
+        self.assertEqual(txs2[0]['support_info'][0]['balance_delta'], '-1.0')
+        self.assertEqual(txs2[0]['support_info'][0]['claim_id'], claim['claim_id'])
+        self.assertEqual(txs2[0]['support_info'][0]['is_tip'], True)
+        self.assertEqual(txs2[0]['value'], '-1.0001415')
+
+        # send a support to the claim using account2
+        support = await self.out(
+            self.daemon.jsonrpc_claim_new_support('hovercraft', claim['claim_id'], '2.0', account2_id)
+        )
+        await self.on_transaction_dict(support)
+        await self.generate(1)
+        await self.on_transaction_dict(support)
+
+        # account2 balance went down ~2
+        self.assertEqual('3.979769', await self.daemon.jsonrpc_account_balance())
+        self.assertEqual('1.999717', await self.daemon.jsonrpc_account_balance(account2_id))
+
+        # verify that the outgoing support is marked correctly as is_tip=False in account2
+        txs2 = await self.out(self.daemon.jsonrpc_transaction_list(account2_id))
+        self.assertEqual(len(txs2[0]['support_info']), 1)
+        self.assertEqual(txs2[0]['support_info'][0]['balance_delta'], '-2.0')
+        self.assertEqual(txs2[0]['support_info'][0]['claim_id'], claim['claim_id'])
+        self.assertEqual(txs2[0]['support_info'][0]['is_tip'], False)
+        self.assertEqual(txs2[0]['value'], '-0.0001415')
diff --git a/tests/integration/wallet/test_transactions.py b/tests/integration/wallet/test_transactions.py
index 90e9e2d19..a1008e70a 100644
--- a/tests/integration/wallet/test_transactions.py
+++ b/tests/integration/wallet/test_transactions.py
@@ -1,13 +1,14 @@
+import logging
 import asyncio
 
-from orchstr8.testcase import IntegrationTestCase
-from lbryschema.claim import ClaimDict
-from lbrynet.wallet.transaction import Transaction
-from lbrynet.wallet.account import generate_certificate
-from lbrynet.wallet.dewies import dewies_to_lbc as d2l, lbc_to_dewies as l2d
+from torba.testcase import IntegrationTestCase
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.extras.wallet.transaction import Transaction
+from lbrynet.extras.wallet.account import generate_certificate
+from lbrynet.extras.wallet.dewies import dewies_to_lbc as d2l, lbc_to_dewies as l2d
 
-import lbryschema
-lbryschema.BLOCKCHAIN_NAME = 'lbrycrd_regtest'
+import lbrynet.schema
+lbrynet.schema.BLOCKCHAIN_NAME = 'lbrycrd_regtest'
 
 
 example_claim_dict = {
@@ -39,7 +40,7 @@ example_claim_dict = {
 
 class BasicTransactionTest(IntegrationTestCase):
 
-    VERBOSE = False
+    VERBOSITY = logging.WARN
 
     async def test_creating_updating_and_abandoning_claim_with_channel(self):
 
@@ -65,13 +66,13 @@ class BasicTransactionTest(IntegrationTestCase):
         await self.broadcast(cert_tx)
         await self.broadcast(claim_tx)
         await asyncio.wait([  # mempool
-            self.on_transaction(claim_tx),
-            self.on_transaction(cert_tx)
+            self.ledger.wait(claim_tx),
+            self.ledger.wait(cert_tx)
         ])
         await self.blockchain.generate(1)
         await asyncio.wait([  # confirmed
-            self.on_transaction(claim_tx),
-            self.on_transaction(cert_tx)
+            self.ledger.wait(claim_tx),
+            self.ledger.wait(cert_tx)
         ])
 
         self.assertEqual(d2l(await self.account.get_balance()), '7.985786')
@@ -83,9 +84,9 @@ class BasicTransactionTest(IntegrationTestCase):
 
         abandon_tx = await Transaction.abandon([claim_tx.outputs[0]], [self.account], self.account)
         await self.broadcast(abandon_tx)
-        await self.on_transaction(abandon_tx)
+        await self.ledger.wait(abandon_tx)
         await self.blockchain.generate(1)
-        await self.on_transaction(abandon_tx)
+        await self.ledger.wait(abandon_tx)
 
         response = await self.ledger.resolve(0, 10, 'lbry://@bar/foo')
         self.assertNotIn('claim', response['lbry://@bar/foo'])
diff --git a/tests/mocks.py b/tests/mocks.py
index 0826410a7..09c93ca95 100644
--- a/tests/mocks.py
+++ b/tests/mocks.py
@@ -1,20 +1,19 @@
 import base64
 import io
-import mock
+from unittest import mock
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization
 from twisted.internet import defer
 from twisted.python.failure import Failure
-
-from lbrynet.core.client.ClientRequest import ClientRequest
-from lbrynet.core.Error import RequestCanceledError
-from lbrynet.core import BlobAvailability
-from lbrynet.file_manager.EncryptedFileManager import EncryptedFileManager
-from lbrynet.dht.node import Node as RealNode
-from lbrynet.daemon import ExchangeRateManager as ERM
 from lbrynet import conf
+from lbrynet.p2p.client.ClientRequest import ClientRequest
+from lbrynet.p2p.Error import RequestCanceledError
+from lbrynet.p2p import BlobAvailability
+from lbrynet.blob.EncryptedFileManager import EncryptedFileManager
+from lbrynet.dht.node import Node as RealNode
+from lbrynet.extras.daemon import ExchangeRateManager as ERM
 
 KB = 2**10
 PUBLIC_EXPONENT = 65537  # http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html
diff --git a/tests/util.py b/tests/test_utils.py
similarity index 84%
rename from tests/util.py
rename to tests/test_utils.py
index e661dd525..ffeaff9fd 100644
--- a/tests/util.py
+++ b/tests/test_utils.py
@@ -3,7 +3,7 @@ import time
 import os
 import tempfile
 import shutil
-import mock
+from unittest import mock
 from binascii import hexlify
 
 
@@ -26,19 +26,20 @@ def random_lbry_hash():
     return hexlify(os.urandom(48)).decode()
 
 
-def resetTime(test_case, timestamp=DEFAULT_TIMESTAMP):
+def reset_time(test_case, timestamp=DEFAULT_TIMESTAMP):
     iso_time = time.mktime(timestamp.timetuple())
     patcher = mock.patch('time.time')
     patcher.start().return_value = iso_time
     test_case.addCleanup(patcher.stop)
 
-    patcher = mock.patch('lbrynet.core.utils.now')
+    patcher = mock.patch('lbrynet.utils.now')
     patcher.start().return_value = timestamp
     test_case.addCleanup(patcher.stop)
 
-    patcher = mock.patch('lbrynet.core.utils.utcnow')
+    patcher = mock.patch('lbrynet.utils.utcnow')
     patcher.start().return_value = timestamp
     test_case.addCleanup(patcher.stop)
 
+
 def is_android():
     return 'ANDROID_ARGUMENT' in os.environ # detect Android using the Kivy way
diff --git a/tests/unit/analytics/test_track.py b/tests/unit/analytics/test_track.py
index e922eae7f..ee3c13fd1 100644
--- a/tests/unit/analytics/test_track.py
+++ b/tests/unit/analytics/test_track.py
@@ -1,4 +1,4 @@
-from lbrynet import analytics
+from lbrynet.extras.daemon import analytics
 
 from twisted.trial import unittest
 
diff --git a/tests/unit/components/test_Component_Manager.py b/tests/unit/components/test_Component_Manager.py
index de6f2863f..782711f43 100644
--- a/tests/unit/components/test_Component_Manager.py
+++ b/tests/unit/components/test_Component_Manager.py
@@ -1,18 +1,19 @@
 from twisted.internet.task import Clock
 from twisted.trial import unittest
 
-from lbrynet.daemon.ComponentManager import ComponentManager
-from lbrynet.daemon.Components import DATABASE_COMPONENT, DHT_COMPONENT, STREAM_IDENTIFIER_COMPONENT
-from lbrynet.daemon.Components import HASH_ANNOUNCER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT
-from lbrynet.daemon.Components import PEER_PROTOCOL_SERVER_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT
-from lbrynet.daemon.Components import RATE_LIMITER_COMPONENT, HEADERS_COMPONENT, PAYMENT_RATE_COMPONENT
-from lbrynet.daemon import Components
+from lbrynet.extras.daemon.ComponentManager import ComponentManager
+from lbrynet.extras.daemon.Components import DATABASE_COMPONENT, DHT_COMPONENT
+from lbrynet.extras.daemon.Components import HASH_ANNOUNCER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT
+from lbrynet.extras.daemon.Components import PEER_PROTOCOL_SERVER_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT
+from lbrynet.extras.daemon.Components import RATE_LIMITER_COMPONENT, HEADERS_COMPONENT, PAYMENT_RATE_COMPONENT
+from lbrynet.extras.daemon import Components
 from tests import mocks
 
 
 class TestComponentManager(unittest.TestCase):
     def setUp(self):
         mocks.mock_conf_settings(self)
+
         self.default_components_sort = [
             [
                 Components.HeadersComponent,
@@ -23,19 +24,14 @@ class TestComponentManager(unittest.TestCase):
                 Components.UPnPComponent
             ],
             [
+                Components.BlobComponent,
                 Components.DHTComponent,
                 Components.WalletComponent
             ],
             [
-                Components.BlobComponent,
-                Components.HashAnnouncerComponent
-            ],
-            [
-                Components.PeerProtocolServerComponent,
-                Components.StreamIdentifierComponent
-            ],
-            [
-                Components.FileManagerComponent
+                Components.FileManagerComponent,
+                Components.HashAnnouncerComponent,
+                Components.PeerProtocolServerComponent
             ],
             [
                 Components.ReflectorComponent
@@ -48,7 +44,6 @@ class TestComponentManager(unittest.TestCase):
 
     def test_sort_components(self):
         stages = self.component_manager.sort_components()
-
         for stage_list, sorted_stage_list in zip(stages, self.default_components_sort):
             self.assertEqual([type(stage) for stage in stage_list], sorted_stage_list)
 
@@ -101,7 +96,7 @@ class TestComponentManagerProperStart(unittest.TestCase):
         self.reactor = Clock()
         mocks.mock_conf_settings(self)
         self.component_manager = ComponentManager(
-            skip_components=[DATABASE_COMPONENT, DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT, STREAM_IDENTIFIER_COMPONENT,
+            skip_components=[DATABASE_COMPONENT, DHT_COMPONENT, HASH_ANNOUNCER_COMPONENT,
                              PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT,
                              HEADERS_COMPONENT, PAYMENT_RATE_COMPONENT, RATE_LIMITER_COMPONENT,
                              EXCHANGE_RATE_MANAGER_COMPONENT],
diff --git a/tests/unit/core/client/test_ConnectionManager.py b/tests/unit/core/client/test_ConnectionManager.py
index 31eaf2e04..7a9d95069 100644
--- a/tests/unit/core/client/test_ConnectionManager.py
+++ b/tests/unit/core/client/test_ConnectionManager.py
@@ -1,17 +1,16 @@
-from lbrynet.core.client.ClientRequest import ClientRequest
-from lbrynet.core.server.ServerProtocol import ServerProtocol
-from lbrynet.core.client.ClientProtocol import ClientProtocol
-from lbrynet.core.RateLimiter import RateLimiter
-from lbrynet.core.Peer import Peer
-from lbrynet.core.PeerManager import PeerManager
-from lbrynet.core.Error import NoResponseError
-
 from twisted.trial.unittest import TestCase
 from twisted.internet import defer, reactor, task
 from twisted.internet.task import deferLater
 from twisted.internet.protocol import ServerFactory
-from lbrynet import conf
-from lbrynet.core import utils
+
+from lbrynet import conf, utils
+from lbrynet.p2p.client.ClientRequest import ClientRequest
+from lbrynet.p2p.server.ServerProtocol import ServerProtocol
+from lbrynet.p2p.client.ClientProtocol import ClientProtocol
+from lbrynet.p2p.RateLimiter import RateLimiter
+from lbrynet.p2p.Peer import Peer
+from lbrynet.p2p.Error import NoResponseError
+from lbrynet.extras.daemon.PeerManager import PeerManager
 
 PEER_PORT = 5551
 LOCAL_HOST = '127.0.0.1'
@@ -131,7 +130,7 @@ class TestIntegrationConnectionManager(TestCase):
 
     def _init_connection_manager(self, seek_head_blob_first=False):
         # this import is required here so utils.call_later is replaced by self.clock.callLater
-        from lbrynet.core.client.ConnectionManager import ConnectionManager
+        from lbrynet.p2p.client.ConnectionManager import ConnectionManager
         self.connection_manager = ConnectionManager(self.downloader, self.rate_limiter,
                                                     [self.primary_request_creator], [])
         self.connection_manager.seek_head_blob_first = seek_head_blob_first
diff --git a/tests/unit/core/server/test_BlobRequestHandler.py b/tests/unit/core/server/test_BlobRequestHandler.py
index 203c32874..953f663ea 100644
--- a/tests/unit/core/server/test_BlobRequestHandler.py
+++ b/tests/unit/core/server/test_BlobRequestHandler.py
@@ -1,13 +1,13 @@
 from io import BytesIO
+from unittest import mock
 
-import mock
 from twisted.internet import defer
 from twisted.test import proto_helpers
 from twisted.trial import unittest
 
-from lbrynet.core import Peer
-from lbrynet.core.server import BlobRequestHandler
-from lbrynet.core.PaymentRateManager import NegotiatedPaymentRateManager, BasePaymentRateManager
+from lbrynet.p2p import Peer
+from lbrynet.p2p.server import BlobRequestHandler
+from lbrynet.p2p.PaymentRateManager import NegotiatedPaymentRateManager, BasePaymentRateManager
 from tests.mocks import BlobAvailabilityTracker as DummyBlobAvailabilityTracker, mock_conf_settings
 
 
diff --git a/tests/unit/core/test_BlobManager.py b/tests/unit/core/test_BlobManager.py
index 9435d176c..70338ff1f 100644
--- a/tests/unit/core/test_BlobManager.py
+++ b/tests/unit/core/test_BlobManager.py
@@ -4,14 +4,14 @@ import os
 import random
 import string
 from twisted.trial import unittest
-from twisted.internet import defer, threads
+from twisted.internet import defer
 
-from tests.util import random_lbry_hash
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.core.Peer import Peer
+from tests.test_utils import random_lbry_hash
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.p2p.Peer import Peer
 from lbrynet import conf
-from lbrynet.core.cryptoutils import get_lbry_hash_obj
+from lbrynet.cryptoutils import get_lbry_hash_obj
 
 
 class BlobManagerTest(unittest.TestCase):
diff --git a/tests/unit/core/test_HTTPBlobDownloader.py b/tests/unit/core/test_HTTPBlobDownloader.py
index 0db0f8753..65dee0d30 100644
--- a/tests/unit/core/test_HTTPBlobDownloader.py
+++ b/tests/unit/core/test_HTTPBlobDownloader.py
@@ -1,11 +1,11 @@
-from mock import MagicMock
+from unittest.mock import MagicMock
 
 from twisted.trial import unittest
 from twisted.internet import defer
 
-from lbrynet.blob import BlobFile
-from lbrynet.core.HTTPBlobDownloader import HTTPBlobDownloader
-from tests.util import mk_db_and_blob_dir, rm_db_and_blob_dir
+from lbrynet.blob.blob_file import BlobFile
+from lbrynet.p2p.HTTPBlobDownloader import HTTPBlobDownloader
+from tests.test_utils import mk_db_and_blob_dir, rm_db_and_blob_dir
 
 
 class HTTPBlobDownloaderTest(unittest.TestCase):
diff --git a/tests/unit/core/test_HashBlob.py b/tests/unit/core/test_HashBlob.py
index 1ec7c88a4..da8b3f5bc 100644
--- a/tests/unit/core/test_HashBlob.py
+++ b/tests/unit/core/test_HashBlob.py
@@ -1,7 +1,7 @@
-from lbrynet.blob import BlobFile
-from lbrynet.core.Error import DownloadCanceledError, InvalidDataError
+from lbrynet.blob.blob_file import BlobFile
+from lbrynet.p2p.Error import DownloadCanceledError, InvalidDataError
 
-from tests.util import mk_db_and_blob_dir, rm_db_and_blob_dir, random_lbry_hash
+from tests.test_utils import mk_db_and_blob_dir, rm_db_and_blob_dir, random_lbry_hash
 from twisted.trial import unittest
 from twisted.internet import defer
 
diff --git a/tests/unit/core/test_Strategy.py b/tests/unit/core/test_Strategy.py
index a49d771e2..57a7c934a 100644
--- a/tests/unit/core/test_Strategy.py
+++ b/tests/unit/core/test_Strategy.py
@@ -1,10 +1,12 @@
 import itertools
-from twisted.trial import unittest
 import random
-import mock
-from lbrynet.core.PaymentRateManager import NegotiatedPaymentRateManager, BasePaymentRateManager
-from lbrynet.core.Strategy import BasicAvailabilityWeightedStrategy
-from lbrynet.core.Offer import Offer
+from unittest import mock
+
+from twisted.trial import unittest
+
+from lbrynet.p2p.PaymentRateManager import NegotiatedPaymentRateManager, BasePaymentRateManager
+from lbrynet.p2p.Strategy import BasicAvailabilityWeightedStrategy
+from lbrynet.p2p.Offer import Offer
 from tests.mocks\
     import BlobAvailabilityTracker as DummyBlobAvailabilityTracker, mock_conf_settings
 
diff --git a/tests/unit/core/test_Wallet.py b/tests/unit/core/test_Wallet.py
index 2f21c1e3a..d5fa5e193 100644
--- a/tests/unit/core/test_Wallet.py
+++ b/tests/unit/core/test_Wallet.py
@@ -1,19 +1,11 @@
 # pylint: skip-file
-import os
-import shutil
 import tempfile
 
 from decimal import Decimal
-from collections import defaultdict
 from twisted.trial import unittest
-from twisted.internet import threads, defer
-from lbrynet.database.storage import SQLiteStorage
-from tests.mocks import FakeNetwork
-from lbrynet.core.Error import InsufficientFundsError
-#from lbrynet.core.Wallet import LBRYumWallet, ReservedPoints
-#from lbryum.commands import Commands
-#from lbryum.simple_config import SimpleConfig
-from lbryschema.claim import ClaimDict
+from twisted.internet import defer
+from lbrynet.p2p.Error import InsufficientFundsError
+from lbrynet.schema.claim import ClaimDict
 
 test_metadata = {
     'license': 'NASA',
diff --git a/tests/unit/core/test_utils.py b/tests/unit/core/test_utils.py
index 208b45ad3..bfb5f8b86 100644
--- a/tests/unit/core/test_utils.py
+++ b/tests/unit/core/test_utils.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-from lbrynet.core import utils
+from lbrynet import utils
 
 from twisted.trial import unittest
 
diff --git a/tests/unit/cryptstream/test_cryptblob.py b/tests/unit/cryptstream/test_cryptblob.py
index 943e7e4f3..d25ef3755 100644
--- a/tests/unit/cryptstream/test_cryptblob.py
+++ b/tests/unit/cryptstream/test_cryptblob.py
@@ -1,6 +1,6 @@
 from twisted.trial import unittest
 from twisted.internet import defer
-from lbrynet.cryptstream import CryptBlob
+from lbrynet.blob import CryptBlob
 from lbrynet.blob.blob_file import MAX_BLOB_SIZE
 
 from tests.mocks import mock_conf_settings
@@ -8,7 +8,7 @@ from tests.mocks import mock_conf_settings
 from cryptography.hazmat.primitives.ciphers.algorithms import AES
 import random
 import string
-from six import BytesIO
+from io import BytesIO
 import os
 
 AES_BLOCK_SIZE_BYTES = int(AES.block_size / 8)
diff --git a/tests/unit/database/test_SQLiteStorage.py b/tests/unit/database/test_SQLiteStorage.py
index ce2783932..e8794bbb7 100644
--- a/tests/unit/database/test_SQLiteStorage.py
+++ b/tests/unit/database/test_SQLiteStorage.py
@@ -6,9 +6,9 @@ from copy import deepcopy
 from twisted.internet import defer
 from twisted.trial import unittest
 from lbrynet import conf
-from lbrynet.database.storage import SQLiteStorage, open_file_for_writing
-from lbrynet.file_manager.EncryptedFileDownloader import ManagedEncryptedFileDownloader
-from tests.util import random_lbry_hash
+from lbrynet.extras.daemon.storage import SQLiteStorage, open_file_for_writing
+from lbrynet.blob.EncryptedFileDownloader import ManagedEncryptedFileDownloader
+from tests.test_utils import random_lbry_hash
 
 log = logging.getLogger()
 
diff --git a/tests/unit/dht/test_contact.py b/tests/unit/dht/test_contact.py
index de219d05d..2721a8fe7 100644
--- a/tests/unit/dht/test_contact.py
+++ b/tests/unit/dht/test_contact.py
@@ -1,7 +1,7 @@
 from binascii import hexlify
 from twisted.internet import task
 from twisted.trial import unittest
-from lbrynet.core.utils import generate_id
+from lbrynet.utils import generate_id
 from lbrynet.dht.contact import ContactManager
 from lbrynet.dht import constants
 
diff --git a/tests/unit/dht/test_hash_announcer.py b/tests/unit/dht/test_hash_announcer.py
index 3ca3c1889..5d7179712 100644
--- a/tests/unit/dht/test_hash_announcer.py
+++ b/tests/unit/dht/test_hash_announcer.py
@@ -1,9 +1,8 @@
 from twisted.trial import unittest
 from twisted.internet import defer, task
-from lbrynet import conf
-from lbrynet.core import utils
-from lbrynet.dht.hashannouncer import DHTHashAnnouncer
-from tests.util import random_lbry_hash
+from lbrynet import utils
+from lbrynet.extras.daemon.HashAnnouncer import DHTHashAnnouncer
+from tests.test_utils import random_lbry_hash
 from tests.mocks import mock_conf_settings
 
 
diff --git a/tests/unit/dht/test_kbucket.py b/tests/unit/dht/test_kbucket.py
index 67e30d4dc..360dee32d 100644
--- a/tests/unit/dht/test_kbucket.py
+++ b/tests/unit/dht/test_kbucket.py
@@ -6,7 +6,7 @@
 
 from twisted.trial import unittest
 import struct
-from lbrynet.core.utils import generate_id
+from lbrynet.utils import generate_id
 from lbrynet.dht import kbucket
 from lbrynet.dht.contact import ContactManager
 from lbrynet.dht import constants
diff --git a/tests/unit/dht/test_node.py b/tests/unit/dht/test_node.py
index 48bdb50a0..983975235 100644
--- a/tests/unit/dht/test_node.py
+++ b/tests/unit/dht/test_node.py
@@ -5,7 +5,7 @@ from twisted.trial import unittest
 from twisted.internet import defer
 from lbrynet.dht.node import Node
 from lbrynet.dht import constants
-from lbrynet.core.utils import generate_id
+from lbrynet.utils import generate_id
 
 
 class NodeIDTest(unittest.TestCase):
diff --git a/tests/unit/dht/test_routingtable.py b/tests/unit/dht/test_routingtable.py
index 89dba21ac..1c7985cc8 100644
--- a/tests/unit/dht/test_routingtable.py
+++ b/tests/unit/dht/test_routingtable.py
@@ -6,7 +6,7 @@ from lbrynet.dht import constants
 from lbrynet.dht.routingtable import TreeRoutingTable
 from lbrynet.dht.contact import ContactManager
 from lbrynet.dht.distance import Distance
-from lbrynet.core.utils import generate_id
+from lbrynet.utils import generate_id
 
 
 class FakeRPCProtocol:
diff --git a/tests/unit/lbryfilemanager/test_EncryptedFileCreator.py b/tests/unit/lbryfilemanager/test_EncryptedFileCreator.py
index 8c771abbb..36d6db299 100644
--- a/tests/unit/lbryfilemanager/test_EncryptedFileCreator.py
+++ b/tests/unit/lbryfilemanager/test_EncryptedFileCreator.py
@@ -1,22 +1,20 @@
 import json
-import mock
 from twisted.trial import unittest
 from twisted.internet import defer
 
 from cryptography.hazmat.primitives.ciphers.algorithms import AES
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.core.StreamDescriptor import get_sd_info, BlobStreamDescriptorReader
-from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.core.PeerManager import PeerManager
-from lbrynet.core.RateLimiter import DummyRateLimiter
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.file_manager import EncryptedFileCreator
-from lbrynet.file_manager.EncryptedFileManager import EncryptedFileManager
-from lbrynet.core.StreamDescriptor import JSONBytesEncoder
+from lbrynet.extras.daemon.PeerManager import PeerManager
+from lbrynet.p2p.StreamDescriptor import get_sd_info, BlobStreamDescriptorReader
+from lbrynet.p2p.StreamDescriptor import StreamDescriptorIdentifier
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.p2p.RateLimiter import DummyRateLimiter
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.blob import EncryptedFileCreator
+from lbrynet.blob.EncryptedFileManager import EncryptedFileManager
+from lbrynet.p2p.StreamDescriptor import JSONBytesEncoder
 from tests import mocks
-from tests.util import mk_db_and_blob_dir, rm_db_and_blob_dir
+from tests.test_utils import mk_db_and_blob_dir, rm_db_and_blob_dir
 
 
 FakeNode = mocks.Node
diff --git a/tests/unit/lbrynet_daemon/auth/test_server.py b/tests/unit/lbrynet_daemon/auth/test_server.py
index d28bb8ad4..505b48226 100644
--- a/tests/unit/lbrynet_daemon/auth/test_server.py
+++ b/tests/unit/lbrynet_daemon/auth/test_server.py
@@ -1,9 +1,10 @@
-import mock
-from twisted.internet import defer, reactor
-from twisted.trial import unittest
-from lbrynet import conf
-from lbrynet.daemon.auth import server
+from unittest import mock
 
+from twisted.internet import reactor
+from twisted.trial import unittest
+
+from lbrynet import conf
+from lbrynet.extras.daemon.auth import server
 from tests.mocks import mock_conf_settings
 
 
diff --git a/tests/unit/lbrynet_daemon/test_Daemon.py b/tests/unit/lbrynet_daemon/test_Daemon.py
index d69601adc..b0713a857 100644
--- a/tests/unit/lbrynet_daemon/test_Daemon.py
+++ b/tests/unit/lbrynet_daemon/test_Daemon.py
@@ -1,4 +1,4 @@
-import mock
+from unittest import mock
 import json
 import random
 from os import path
@@ -7,45 +7,40 @@ from twisted.internet import defer
 from twisted.trial import unittest
 
 from faker import Faker
-
-from lbryschema.decode import smart_decode
 from lbrynet import conf
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.daemon.ComponentManager import ComponentManager
-from lbrynet.daemon.Components import DATABASE_COMPONENT, DHT_COMPONENT, WALLET_COMPONENT, STREAM_IDENTIFIER_COMPONENT
-from lbrynet.daemon.Components import f2d
-from lbrynet.daemon.Components import HASH_ANNOUNCER_COMPONENT, REFLECTOR_COMPONENT, UPNP_COMPONENT, BLOB_COMPONENT
-from lbrynet.daemon.Components import PEER_PROTOCOL_SERVER_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT
-from lbrynet.daemon.Components import RATE_LIMITER_COMPONENT, HEADERS_COMPONENT, FILE_MANAGER_COMPONENT
-from lbrynet.daemon.Daemon import Daemon as LBRYDaemon
-from lbrynet.file_manager.EncryptedFileDownloader import ManagedEncryptedFileDownloader
-from lbrynet.wallet.manager import LbryWalletManager
-from torba.wallet import Wallet
+from lbrynet.schema.decode import smart_decode
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.extras.daemon.ComponentManager import ComponentManager
+from lbrynet.extras.daemon.Components import DATABASE_COMPONENT, DHT_COMPONENT, WALLET_COMPONENT
+from lbrynet.extras.daemon.Components import f2d
+from lbrynet.extras.daemon.Components import HASH_ANNOUNCER_COMPONENT, REFLECTOR_COMPONENT
+from lbrynet.extras.daemon.Components import UPNP_COMPONENT, BLOB_COMPONENT
+from lbrynet.extras.daemon.Components import PEER_PROTOCOL_SERVER_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT
+from lbrynet.extras.daemon.Components import RATE_LIMITER_COMPONENT, HEADERS_COMPONENT, FILE_MANAGER_COMPONENT
+from lbrynet.extras.daemon.Daemon import Daemon as LBRYDaemon
+from lbrynet.blob.EncryptedFileDownloader import ManagedEncryptedFileDownloader
+from lbrynet.extras.wallet import LbryWalletManager
+from torba.client.wallet import Wallet
 
-from lbrynet.core.PaymentRateManager import OnlyFreePaymentsManager
-from tests import util
+from lbrynet.p2p.PaymentRateManager import OnlyFreePaymentsManager
+from tests import test_utils
 from tests.mocks import mock_conf_settings, FakeNetwork, FakeFileManager
 from tests.mocks import ExchangeRateManager as DummyExchangeRateManager
 from tests.mocks import BTCLBCFeed, USDBTCFeed
-from tests.util import is_android
-
-
-import logging
-logging.getLogger("lbryum").setLevel(logging.WARNING)
+from tests.test_utils import is_android
 
 
 def get_test_daemon(data_rate=None, generous=True, with_fee=False):
     if data_rate is None:
         data_rate = conf.ADJUSTABLE_SETTINGS['data_rate'][1]
-
     rates = {
-        'BTCLBC': {'spot': 3.0, 'ts': util.DEFAULT_ISO_TIME + 1},
-        'USDBTC': {'spot': 2.0, 'ts': util.DEFAULT_ISO_TIME + 2}
+        'BTCLBC': {'spot': 3.0, 'ts': test_utils.DEFAULT_ISO_TIME + 1},
+        'USDBTC': {'spot': 2.0, 'ts': test_utils.DEFAULT_ISO_TIME + 2}
     }
     component_manager = ComponentManager(
         skip_components=[DATABASE_COMPONENT, DHT_COMPONENT, WALLET_COMPONENT, UPNP_COMPONENT,
                          PEER_PROTOCOL_SERVER_COMPONENT, REFLECTOR_COMPONENT, HASH_ANNOUNCER_COMPONENT,
-                         STREAM_IDENTIFIER_COMPONENT, EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
+                         EXCHANGE_RATE_MANAGER_COMPONENT, BLOB_COMPONENT,
                          HEADERS_COMPONENT, RATE_LIMITER_COMPONENT],
         file_manager=FakeFileManager
     )
@@ -89,7 +84,7 @@ class TestCostEst(unittest.TestCase):
 
     def setUp(self):
         mock_conf_settings(self)
-        util.resetTime(self)
+        test_utils.reset_time(self)
 
     @defer.inlineCallbacks
     def test_fee_and_generous_data(self):
@@ -134,7 +129,7 @@ class TestJsonRpc(unittest.TestCase):
             return None
 
         mock_conf_settings(self)
-        util.resetTime(self)
+        test_utils.reset_time(self)
         self.test_daemon = get_test_daemon()
         self.test_daemon.wallet_manager.is_first_run = False
         self.test_daemon.wallet_manager.get_best_blockhash = noop
@@ -156,7 +151,7 @@ class TestFileListSorting(unittest.TestCase):
 
     def setUp(self):
         mock_conf_settings(self)
-        util.resetTime(self)
+        test_utils.reset_time(self)
         self.faker = Faker('en_US')
         self.faker.seed(129)  # contains 3 same points paid (5.9)
         self.test_daemon = get_test_daemon()
diff --git a/tests/unit/lbrynet_daemon/test_Downloader.py b/tests/unit/lbrynet_daemon/test_Downloader.py
index 2f05c5890..36a5e97a5 100644
--- a/tests/unit/lbrynet_daemon/test_Downloader.py
+++ b/tests/unit/lbrynet_daemon/test_Downloader.py
@@ -1,21 +1,22 @@
 import types
-import mock
+from unittest import mock
 from twisted.trial import unittest
 from twisted.internet import defer, task
 
 
-from lbrynet.core import PaymentRateManager
-from lbrynet.core.Error import DownloadDataTimeout, DownloadSDTimeout
-from lbrynet.core.StreamDescriptor import StreamDescriptorIdentifier
-from lbrynet.core.BlobManager import DiskBlobManager
-from lbrynet.core.RateLimiter import DummyRateLimiter
-from lbrynet.daemon import Downloader
-from lbrynet.daemon.ExchangeRateManager import ExchangeRateManager
-from lbrynet.database.storage import SQLiteStorage
-from lbrynet.dht.peerfinder import DummyPeerFinder
-from lbrynet.file_manager.EncryptedFileStatusReport import EncryptedFileStatusReport
-from lbrynet.file_manager.EncryptedFileDownloader import ManagedEncryptedFileDownloader
-from lbrynet.wallet.manager import LbryWalletManager
+from lbrynet.p2p import PaymentRateManager
+from lbrynet.p2p.Error import DownloadDataTimeout, DownloadSDTimeout
+from lbrynet.p2p.StreamDescriptor import StreamDescriptorIdentifier
+from lbrynet.p2p.BlobManager import DiskBlobManager
+from lbrynet.p2p.RateLimiter import DummyRateLimiter
+from lbrynet.p2p.client.DownloadManager import DownloadManager
+from lbrynet.extras.daemon import Downloader
+from lbrynet.extras.daemon import ExchangeRateManager
+from lbrynet.extras.daemon.storage import SQLiteStorage
+from lbrynet.extras.daemon.PeerFinder import DummyPeerFinder
+from lbrynet.blob.EncryptedFileStatusReport import EncryptedFileStatusReport
+from lbrynet.blob.EncryptedFileDownloader import ManagedEncryptedFileDownloader
+from lbrynet.extras.wallet import LbryWalletManager
 
 from tests.mocks import mock_conf_settings
 
@@ -24,7 +25,7 @@ class MocDownloader:
     def __init__(self):
         self.finish_deferred = defer.Deferred(None)
         self.stop_called = False
-
+        self.file_name = 'test'
         self.name = 'test'
         self.num_completed = 0
         self.num_known = 1
@@ -60,8 +61,10 @@ def moc_download(self, sd_blob, name, txid, nout, key_fee, file_name):
     self.downloader.start()
 
 
-def moc_pay_key_fee(self, key_fee, name):
-    self.pay_key_fee_called = True
+def moc_pay_key_fee(d):
+    def _moc_pay_key_fee(self, key_fee, name):
+        d.callback(True)
+    return _moc_pay_key_fee
 
 
 class GetStreamTests(unittest.TestCase):
@@ -83,10 +86,7 @@ class GetStreamTests(unittest.TestCase):
             sd_identifier, wallet, exchange_rate_manager, blob_manager, peer_finder, DummyRateLimiter(), prm,
             storage, max_key_fee, disable_max_key_fee, timeout=3, data_rate=data_rate
         )
-        getstream.pay_key_fee_called = False
-
-        self.clock = task.Clock()
-        getstream.checker.clock = self.clock
+        getstream.download_manager = mock.Mock(spec=DownloadManager)
         return getstream
 
     @defer.inlineCallbacks
@@ -112,16 +112,18 @@ class GetStreamTests(unittest.TestCase):
         def download_sd_blob(self):
             raise DownloadSDTimeout(self)
 
+        called_pay_fee = defer.Deferred()
+
         getstream = self.init_getstream_with_mocs()
         getstream._initialize = types.MethodType(moc_initialize, getstream)
         getstream._download_sd_blob = types.MethodType(download_sd_blob, getstream)
         getstream._download = types.MethodType(moc_download, getstream)
-        getstream.pay_key_fee = types.MethodType(moc_pay_key_fee, getstream)
+        getstream.pay_key_fee = types.MethodType(moc_pay_key_fee(called_pay_fee), getstream)
         name = 'test'
         stream_info = None
         with self.assertRaises(DownloadSDTimeout):
             yield getstream.start(stream_info, name, "deadbeef" * 12, 0)
-        self.assertFalse(getstream.pay_key_fee_called)
+        self.assertFalse(called_pay_fee.called)
 
     @defer.inlineCallbacks
     def test_timeout(self):
@@ -129,20 +131,18 @@ class GetStreamTests(unittest.TestCase):
         test that timeout (set to 3 here) exception is raised
         when download times out while downloading first blob, and key fee is paid
         """
+        called_pay_fee = defer.Deferred()
+
         getstream = self.init_getstream_with_mocs()
         getstream._initialize = types.MethodType(moc_initialize, getstream)
         getstream._download_sd_blob = types.MethodType(moc_download_sd_blob, getstream)
         getstream._download = types.MethodType(moc_download, getstream)
-        getstream.pay_key_fee = types.MethodType(moc_pay_key_fee, getstream)
+        getstream.pay_key_fee = types.MethodType(moc_pay_key_fee(called_pay_fee), getstream)
         name = 'test'
         stream_info = None
         start = getstream.start(stream_info, name, "deadbeef" * 12, 0)
-        self.clock.advance(1)
-        self.clock.advance(1)
-        self.clock.advance(1)
         with self.assertRaises(DownloadDataTimeout):
             yield start
-        self.assertTrue(getstream.pay_key_fee_called)
 
     @defer.inlineCallbacks
     def test_finish_one_blob(self):
@@ -150,20 +150,22 @@ class GetStreamTests(unittest.TestCase):
         test that if we have 1 completed blob, start() returns
         and key fee is paid
         """
+        called_pay_fee = defer.Deferred()
+
         getstream = self.init_getstream_with_mocs()
         getstream._initialize = types.MethodType(moc_initialize, getstream)
 
         getstream._download_sd_blob = types.MethodType(moc_download_sd_blob, getstream)
         getstream._download = types.MethodType(moc_download, getstream)
-        getstream.pay_key_fee = types.MethodType(moc_pay_key_fee, getstream)
+        getstream.pay_key_fee = types.MethodType(moc_pay_key_fee(called_pay_fee), getstream)
         name = 'test'
         stream_info = None
-        start = getstream.start(stream_info, name, "deadbeef" * 12, 0)
-        getstream.downloader.num_completed = 1
-        self.clock.advance(1)
+        self.assertFalse(getstream.wrote_data)
+        getstream.data_downloading_deferred.callback(None)
+        yield getstream.start(stream_info, name, "deadbeef" * 12, 0)
+        self.assertTrue(getstream.wrote_data)
 
-        downloader, f_deferred = yield start
-        self.assertTrue(getstream.pay_key_fee_called)
+        # self.assertTrue(getstream.pay_key_fee_called)
 
     # @defer.inlineCallbacks
     # def test_finish_stopped_downloader(self):
diff --git a/tests/unit/lbrynet_daemon/test_ExchangeRateManager.py b/tests/unit/lbrynet_daemon/test_ExchangeRateManager.py
index c1f703821..cd758d88a 100644
--- a/tests/unit/lbrynet_daemon/test_ExchangeRateManager.py
+++ b/tests/unit/lbrynet_daemon/test_ExchangeRateManager.py
@@ -1,9 +1,9 @@
-from lbryschema.fee import Fee
-from lbrynet.daemon import ExchangeRateManager
-from lbrynet.core.Error import InvalidExchangeRateResponse
+from lbrynet.schema.fee import Fee
+from lbrynet.extras.daemon import ExchangeRateManager
+from lbrynet.p2p.Error import InvalidExchangeRateResponse
 from twisted.trial import unittest
 from twisted.internet import defer
-from tests import util
+from tests import test_utils
 from tests.mocks import ExchangeRateManager as DummyExchangeRateManager
 from tests.mocks import BTCLBCFeed, USDBTCFeed
 
@@ -32,18 +32,18 @@ class FeeFormatTest(unittest.TestCase):
 
 class ExchangeRateTest(unittest.TestCase):
     def setUp(self):
-        util.resetTime(self)
+        test_utils.reset_time(self)
 
     def test_invalid_rates(self):
         with self.assertRaises(ValueError):
-            ExchangeRateManager.ExchangeRate('USDBTC', 0, util.DEFAULT_ISO_TIME)
+            ExchangeRateManager.ExchangeRate('USDBTC', 0, test_utils.DEFAULT_ISO_TIME)
         with self.assertRaises(ValueError):
-            ExchangeRateManager.ExchangeRate('USDBTC', -1, util.DEFAULT_ISO_TIME)
+            ExchangeRateManager.ExchangeRate('USDBTC', -1, test_utils.DEFAULT_ISO_TIME)
 
 
 class FeeTest(unittest.TestCase):
     def setUp(self):
-        util.resetTime(self)
+        test_utils.reset_time(self)
 
     def test_fee_converts_to_lbc(self):
         fee = Fee({
@@ -53,8 +53,8 @@ class FeeTest(unittest.TestCase):
             })
 
         rates = {
-            'BTCLBC': {'spot': 3.0, 'ts': util.DEFAULT_ISO_TIME + 1},
-            'USDBTC': {'spot': 2.0, 'ts': util.DEFAULT_ISO_TIME + 2}
+            'BTCLBC': {'spot': 3.0, 'ts': test_utils.DEFAULT_ISO_TIME + 1},
+            'USDBTC': {'spot': 2.0, 'ts': test_utils.DEFAULT_ISO_TIME + 2}
         }
 
         market_feeds = [BTCLBCFeed(), USDBTCFeed()]
@@ -71,7 +71,7 @@ class FeeTest(unittest.TestCase):
             })
 
         rates = {
-            'BTCLBC': {'spot': 1.0, 'ts': util.DEFAULT_ISO_TIME + 1},
+            'BTCLBC': {'spot': 1.0, 'ts': test_utils.DEFAULT_ISO_TIME + 1},
         }
         market_feeds = [BTCLBCFeed()]
         manager = DummyExchangeRateManager(market_feeds, rates)
diff --git a/tests/unit/lbrynet_daemon/test_claims_comparator.py b/tests/unit/lbrynet_daemon/test_claims_comparator.py
index 4a4333aba..a1d6dd0aa 100644
--- a/tests/unit/lbrynet_daemon/test_claims_comparator.py
+++ b/tests/unit/lbrynet_daemon/test_claims_comparator.py
@@ -1,6 +1,6 @@
-import unittest
+from twisted.trial import unittest
 
-from lbrynet.daemon.Daemon import sort_claim_results
+from lbrynet.extras.daemon.Daemon import sort_claim_results
 
 
 class ClaimsComparatorTest(unittest.TestCase):
diff --git a/tests/unit/lbrynet_daemon/test_docs.py b/tests/unit/lbrynet_daemon/test_docs.py
index 139a720a3..4b7626204 100644
--- a/tests/unit/lbrynet_daemon/test_docs.py
+++ b/tests/unit/lbrynet_daemon/test_docs.py
@@ -1,6 +1,6 @@
 import docopt
 from twisted.trial import unittest
-from lbrynet.daemon.Daemon import Daemon
+from lbrynet.extras.daemon.Daemon import Daemon
 
 
 class DaemonDocsTests(unittest.TestCase):
diff --git a/tests/unit/schema/__init__.py b/tests/unit/schema/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/schema/test_data.py b/tests/unit/schema/test_data.py
new file mode 100644
index 000000000..b564daf25
--- /dev/null
+++ b/tests/unit/schema/test_data.py
@@ -0,0 +1,219 @@
+
+
+claim_id_1 = "63f2da17b0d90042c559cc73b6b17f853945c43e"
+
+claim_address_2 = "bDtL6qriyimxz71DSYjojTBsm6cpM1bqmj"
+
+claim_address_1 = "bUG7VaMzLEqqyZQAyg9srxQzvf1wwnJ48w"
+
+nist256p_private_key = """-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIBhixPFinjHmG94r00VBjmE73XZmlSHag5Bg3BFdCeQgoAoGCCqGSM49
+AwEHoUQDQgAEtSfatRTR6ppwoDVJ94hbvhFDF42mACkWSc2Tao6zzYW4xaRPbI7j
+IBUL+6prbDM+GXZ8X2mtmeaNIgjWTT7YFw==
+-----END EC PRIVATE KEY-----
+"""
+
+nist384p_private_key = """-----BEGIN EC PRIVATE KEY-----
+MIGkAgEBBDD5PPbcgT62WADeVBkDFsKCTCwQULHD7eE0iZz7c9Xk+6gZazMFgsGp
+O0Rs9n+lmACgBwYFK4EEACKhZANiAASzpp0t4nIxoedhQN+J2pZ/EmwZl/x4dwdd
+AjY4ZwKBdhfWIWgtcET9PBJlda0EvxR+CTwrt1em26VNS/57eH3yNFJQdCQiMSFY
+mTtML6D/rctN1oztTSQdwHPA9x99FcU=
+-----END EC PRIVATE KEY-----
+"""
+
+secp256k1_private_key = """-----BEGIN EC PRIVATE KEY-----
+MHQCAQEEIPbjaEfCCCy5HHvGHkEw3X/dTJXlr4jcEJHV1OmcBDPmoAcGBSuBBAAK
+oUQDQgAElLPrkVIapvtKrv0DkgQb9vAXtCQDBIu+iHlsQC5dx1ZnOWZwpYKQuM4i
+LNbuTlfxCHWYwovwLjYnao8iwgp0og==
+-----END EC PRIVATE KEY-----
+"""
+
+nist256p_cert = {
+  "version": "_0_0_1", 
+  "claimType": "certificateType", 
+  "certificate": {
+    "publicKey": "3059301306072a8648ce3d020106082a8648ce3d03010703420004b527dab514d1ea9a70a03549f7885bbe1143178da600291649cd936a8eb3cd85b8c5a44f6c8ee320150bfbaa6b6c333e19767c5f69ad99e68d2208d64d3ed817", 
+    "keyType": "NIST256p", 
+    "version": "_0_0_1"
+  }
+}
+
+nist384p_cert = {
+  "version": "_0_0_1", 
+  "claimType": "certificateType", 
+  "certificate": {
+    "publicKey": "3076301006072a8648ce3d020106052b8104002203620004b3a69d2de27231a1e76140df89da967f126c1997fc7877075d0236386702817617d621682d7044fd3c126575ad04bf147e093c2bb757a6dba54d4bfe7b787df2345250742422312158993b4c2fa0ffadcb4dd68ced4d241dc073c0f71f7d15c5", 
+    "keyType": "NIST384p", 
+    "version": "_0_0_1"
+  }
+}
+
+secp256k1_cert = {
+  "version": "_0_0_1", 
+  "claimType": "certificateType", 
+  "certificate": {
+    "publicKey": "3056301006072a8648ce3d020106052b8104000a0342000494b3eb91521aa6fb4aaefd0392041bf6f017b42403048bbe88796c402e5dc75667396670a58290b8ce222cd6ee4e57f1087598c28bf02e36276a8f22c20a74a2", 
+    "keyType": "SECP256k1", 
+    "version": "_0_0_1"
+  }
+}
+
+malformed_secp256k1_cert = {
+  "version": "_0_0_1",
+  "claimType": "certificateType",
+  "certificate": {
+    "publicKey": "3056301006072a8648ce3d020106052b8104000a0342000494b3eb91521aa6fb4aaefd0392041bf6f017b42403048bbe88796c402e5dc75667396670a58290b8ce222cd6ee4e57f1087598c28bf02e36276a8f22c20a74a2",
+    "keyType": "NIST256p",
+    "version": "_0_0_1"
+  }
+}
+
+example_003 = {
+  "language": "en", 
+  "license": "LBRY Inc", 
+  "nsfw": False, 
+  "description": "What is LBRY? An introduction with Alex Tabarrok", 
+  "content_type": "video/mp4", 
+  "author": "Samuel Bryan", 
+  "ver": "0.0.3", 
+  "title": "What is LBRY?", 
+  "sources": {
+    "lbry_sd_hash": "d5169241150022f996fa7cd6a9a1c421937276a3275eb912790bd07ba7aec1fac5fd45431d226b8fb402691e79aeb24b"
+  }, 
+  "thumbnail": "https://s3.amazonaws.com/files.lbry.io/logo.png"
+}
+
+example_010 = {
+  "version": "_0_0_1", 
+  "claimType": "streamType", 
+  "stream": {
+    "source": {
+      "source": "d5169241150022f996fa7cd6a9a1c421937276a3275eb912790bd07ba7aec1fac5fd45431d226b8fb402691e79aeb24b", 
+      "version": "_0_0_1", 
+      "contentType": "video/mp4", 
+      "sourceType": "lbry_sd_hash"
+    }, 
+    "version": "_0_0_1", 
+    "metadata": {
+      "license": "LBRY Inc", 
+      "description": "What is LBRY? An introduction with Alex Tabarrok", 
+      "language": "en", 
+      "title": "What is LBRY?", 
+      "author": "Samuel Bryan", 
+      "version": "_0_1_0", 
+      "nsfw": False, 
+      "licenseUrl": "", 
+      "preview": "", 
+      "thumbnail": "https://s3.amazonaws.com/files.lbry.io/logo.png"
+    }
+  }
+}
+
+example_010_serialized = "080110011adc010801129401080410011a0d57686174206973204c4252593f223057686174206973204c4252593f20416e20696e74726f64756374696f6e207769746820416c6578205461626172726f6b2a0c53616d75656c20427279616e32084c42525920496e6338004a2f68747470733a2f2f73332e616d617a6f6e6177732e636f6d2f66696c65732e6c6272792e696f2f6c6f676f2e706e6752005a001a41080110011a30d5169241150022f996fa7cd6a9a1c421937276a3275eb912790bd07ba7aec1fac5fd45431d226b8fb402691e79aeb24b2209766964656f2f6d7034"
+
+claim_010_signed_nist256p = {
+  "version": "_0_0_1", 
+  "publisherSignature": {
+    "certificateId": "63f2da17b0d90042c559cc73b6b17f853945c43e", 
+    "signatureType": "NIST256p", 
+    "version": "_0_0_1", 
+    "signature": "ec117f5e16a911f704aab8efa9178b1cdfcad0ba8e571ba86a56ecdade129fdff60ff7dcf00355bda788020a43a40fbd55aaaa080c3555fd8f0a87612b62936a"
+  }, 
+  "claimType": "streamType", 
+  "stream": {
+    "source": {
+      "source": "d5169241150022f996fa7cd6a9a1c421937276a3275eb912790bd07ba7aec1fac5fd45431d226b8fb402691e79aeb24b", 
+      "version": "_0_0_1", 
+      "contentType": "video/mp4", 
+      "sourceType": "lbry_sd_hash"
+    }, 
+    "version": "_0_0_1", 
+    "metadata": {
+      "license": "LBRY Inc", 
+      "description": "What is LBRY? An introduction with Alex Tabarrok", 
+      "language": "en", 
+      "title": "What is LBRY?", 
+      "author": "Samuel Bryan", 
+      "version": "_0_1_0", 
+      "nsfw": False, 
+      "licenseUrl": "", 
+      "preview": "", 
+      "thumbnail": "https://s3.amazonaws.com/files.lbry.io/logo.png"
+    }
+  }
+}
+
+claim_010_signed_nist384p = {
+  "version": "_0_0_1", 
+  "publisherSignature": {
+    "certificateId": "63f2da17b0d90042c559cc73b6b17f853945c43e", 
+    "signatureType": "NIST384p", 
+    "version": "_0_0_1", 
+    "signature": "18e56bb52872809ac598c366c5f0fa9ecbcadb01198b7150b0c4518049086b6b4f552f01d16eaf9cbbf061d8ee35520f8fe22f278a4d0aab5f9c8a4cadd38b6bd4bdbb3b4368e24c6e966ebc24684d24f3d19f5a3e4c7bf69273b0f94aa1c51b"
+  }, 
+  "claimType": "streamType", 
+  "stream": {
+    "source": {
+      "source": "d5169241150022f996fa7cd6a9a1c421937276a3275eb912790bd07ba7aec1fac5fd45431d226b8fb402691e79aeb24b", 
+      "version": "_0_0_1", 
+      "contentType": "video/mp4", 
+      "sourceType": "lbry_sd_hash"
+    }, 
+    "version": "_0_0_1", 
+    "metadata": {
+      "license": "LBRY Inc", 
+      "description": "What is LBRY? An introduction with Alex Tabarrok", 
+      "language": "en", 
+      "title": "What is LBRY?", 
+      "author": "Samuel Bryan", 
+      "version": "_0_1_0", 
+      "nsfw": False, 
+      "licenseUrl": "", 
+      "preview": "", 
+      "thumbnail": "https://s3.amazonaws.com/files.lbry.io/logo.png"
+    }
+  }
+}
+
+claim_010_signed_secp256k1 = {
+  "version": "_0_0_1", 
+  "publisherSignature": {
+    "certificateId": "63f2da17b0d90042c559cc73b6b17f853945c43e", 
+    "signatureType": "SECP256k1", 
+    "version": "_0_0_1", 
+    "signature": "798a37bd4310339e6a9b424ebc3fd2b3263280c13c0d08b1d1fa5e53d29c102b2d340cedecc5018988819db0ac6eb61bf67dbeec4ebee7231668fd13931e6320"
+  }, 
+  "claimType": "streamType", 
+  "stream": {
+    "source": {
+      "source": "d5169241150022f996fa7cd6a9a1c421937276a3275eb912790bd07ba7aec1fac5fd45431d226b8fb402691e79aeb24b", 
+      "version": "_0_0_1", 
+      "contentType": "video/mp4", 
+      "sourceType": "lbry_sd_hash"
+    }, 
+    "version": "_0_0_1", 
+    "metadata": {
+      "license": "LBRY Inc", 
+      "description": "What is LBRY? An introduction with Alex Tabarrok", 
+      "language": "en", 
+      "title": "What is LBRY?", 
+      "author": "Samuel Bryan", 
+      "version": "_0_1_0", 
+      "nsfw": False, 
+      "licenseUrl": "", 
+      "preview": "", 
+      "thumbnail": "https://s3.amazonaws.com/files.lbry.io/logo.png"
+    }
+  }
+}
+
+hex_encoded_003="7b22766572223a2022302e302e33222c20226465736372697074696f6e223a202274657374222c20226c6963656e7365223a2022437265617469766520436f6d6d6f6e73204174747269627574696f6e20342e3020496e7465726e6174696f6e616c222c2022617574686f72223a202274657374222c20227469746c65223a202274657374222c20226c616e6775616765223a2022656e222c2022736f7572636573223a207b226c6272795f73645f68617368223a2022323961643231386336316335393934393962323263313732323833373162356665396136653732356564633965663639316137383139623365373430363530303436373835323932303632396662636464626361636631336433313537396434227d2c2022636f6e74656e745f74797065223a2022696d6167652f706e67222c20226e736677223a2066616c73657d"
+
+decoded_hex_encoded_003={u'version': u'_0_0_1', u'claimType': u'streamType', u'stream': {u'source': {u'source': '29ad218c61c599499b22c17228371b5fe9a6e725edc9ef691a7819b3e7406500467852920629fbcddbcacf13d31579d4', u'version': u'_0_0_1', u'contentType': u'image/png', u'sourceType': u'lbry_sd_hash'}, u'version': u'_0_0_1', u'metadata': {u'license': u'Creative Commons Attribution 4.0 International', u'description': u'test', u'language': u'en', u'title': u'test', u'author': u'test', u'version': u'_0_1_0', u'nsfw': False, u'licenseUrl': u'', u'preview': u'', u'thumbnail': u''}}}
+
+binary_claim = b'\x08\x01\x10\x02"^\x08\x01\x10\x03"X0V0\x10\x06\x07*\x86H\xce=\x02\x01\x06\x05+\x81\x04\x00\n\x03B\x00\x04\x89U\x97\x1dk\xbc\xd4\xf7\xe2\xb5\xa9a7\xbc\xa4;\xda\x9a\x13\x84<\x05"\xa5\xc3\no;u\xb6\x8co\x10\x81\x8c\x1d\xf2\xe7\t\x9c.\xc8\x9b\x84\xabz:6\x15\xa5\xb3\x16\n\x03YT&M\x98\xec+\xef\x89;'
+expected_binary_claim_decoded = {u'certificate': {u'keyType': u'SECP256k1',
+                  u'publicKey': u'3056301006072a8648ce3d020106052b8104000a034200048955971d6bbcd4f7e2b5a96137bca43bda9a13843c0522a5c30a6f3b75b68c6f10818c1df2e7099c2ec89b84ab7a3a3615a5b3160a035954264d98ec2bef893b',
+                  u'version': u'_0_0_1'},
+                  u'claimType': u'certificateType',
+                  u'version': u'_0_0_1'}
\ No newline at end of file
diff --git a/tests/unit/schema/test_lbryschema.py b/tests/unit/schema/test_lbryschema.py
new file mode 100644
index 000000000..8394ed742
--- /dev/null
+++ b/tests/unit/schema/test_lbryschema.py
@@ -0,0 +1,423 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import ecdsa
+import binascii
+from copy import deepcopy
+import unittest
+
+from .test_data import example_003, example_010, example_010_serialized
+from .test_data import claim_id_1, claim_address_1, claim_address_2
+from .test_data import binary_claim, expected_binary_claim_decoded
+from .test_data import nist256p_private_key, claim_010_signed_nist256p, nist256p_cert
+from .test_data import nist384p_private_key, claim_010_signed_nist384p, nist384p_cert
+from .test_data import secp256k1_private_key, claim_010_signed_secp256k1, secp256k1_cert
+from .test_data import hex_encoded_003, decoded_hex_encoded_003, malformed_secp256k1_cert
+from lbrynet import schema
+from lbrynet.schema.claim import ClaimDict
+from lbrynet.schema.schema import NIST256p, NIST384p, SECP256k1
+from lbrynet.schema.legacy.migrate import migrate
+from lbrynet.schema.signer import get_signer
+from lbrynet.schema.uri import URI, URIParseError
+from lbrynet.schema.decode import smart_decode
+from lbrynet.schema.error import DecodeError, InvalidAddress
+from lbrynet.schema.address import decode_address, encode_address
+
+
+parsed_uri_matches = [
+    ("test", URI("test"), False),
+    ("test#%s" % claim_id_1, URI("test", claim_id=claim_id_1), False),
+    ("test:1", URI("test", claim_sequence=1), False),
+    ("test$1", URI("test", bid_position=1), False),
+    ("lbry://test", URI("test"), False),
+    ("lbry://test#%s" % claim_id_1, URI("test", claim_id=claim_id_1), False),
+    ("lbry://test:1", URI("test", claim_sequence=1), False),
+    ("lbry://test$1", URI("test", bid_position=1), False),
+    ("@test", URI("@test"), True),
+    ("@test#%s" % claim_id_1, URI("@test", claim_id=claim_id_1), True),
+    ("@test:1", URI("@test", claim_sequence=1), True),
+    ("@test$1", URI("@test", bid_position=1), True),
+    ("lbry://@test1:1/fakepath", URI("@test1", claim_sequence=1, path="fakepath"), True),
+    ("lbry://@test1$1/fakepath", URI("@test1", bid_position=1, path="fakepath"), True),
+    ("lbry://@test1#abcdef/fakepath", URI("@test1", claim_id="abcdef", path="fakepath"), True),
+    ("@z", URI("@z"), True),
+    ("@yx", URI("@yx"), True),
+    ("@abc", URI("@abc"), True)
+]
+
+parsed_uri_raises = [
+    ("lbry://", URIParseError),
+    ("lbry://test:3$1", URIParseError),
+    ("lbry://test$1:1", URIParseError),
+    ("lbry://test#x", URIParseError),
+    ("lbry://test#x/page", URIParseError),
+    ("lbry://test$", URIParseError),
+    ("lbry://test#", URIParseError),
+    ("lbry://test:", URIParseError),
+    ("lbry://test$x", URIParseError),
+    ("lbry://test:x", URIParseError),
+    ("lbry://@test@", URIParseError),
+    ("lbry://@test:", URIParseError),
+    ("lbry://test@", URIParseError),
+    ("lbry://tes@t", URIParseError),
+    ("lbry://test:1#%s" % claim_id_1, URIParseError),
+    ("lbry://test:0", URIParseError),
+    ("lbry://test$0", URIParseError),
+    ("lbry://test/path", URIParseError),
+    ("lbry://@test1#abcdef/fakepath:1", URIParseError),
+    ("lbry://@test1:1/fakepath:1", URIParseError),
+    ("lbry://@test1:1ab/fakepath", URIParseError),
+    ("lbry://test:1:1:1", URIParseError),
+    ("whatever/lbry://test", URIParseError),
+    ("lbry://lbry://test", URIParseError),
+    ("lbry://❀", URIParseError),
+    ("lbry://@/what", URIParseError),
+    ("lbry://abc:0x123", URIParseError),
+    ("lbry://abc:0x123/page", URIParseError),
+    ("lbry://@test1#ABCDEF/fakepath", URIParseError),
+    ("test:0001", URIParseError),
+    ("lbry://@test1$1/fakepath?arg1&arg2&arg3", URIParseError)
+]
+
+
+class UnitTest(unittest.TestCase):
+    maxDiff = 4000
+
+
+class TestURIParser(UnitTest):
+    def setUp(self):
+        self.longMessage = True
+
+    def test_uri_parse(self):
+        for test_string, expected_uri_obj, is_channel in parsed_uri_matches:
+            try:
+                # string -> URI
+                self.assertEqual(URI.from_uri_string(test_string), expected_uri_obj, test_string)
+                # URI -> dict -> URI
+                self.assertEqual(URI.from_dict(expected_uri_obj.to_dict()), expected_uri_obj,
+                                  test_string)
+                # is_channel
+                self.assertEqual(URI.from_uri_string(test_string).is_channel, is_channel,
+                                  test_string)
+
+                # convert-to-string test only works if protocol is present in test_string
+                if test_string.startswith('lbry://'):
+                    # string -> URI -> string
+                    self.assertEqual(URI.from_uri_string(test_string).to_uri_string(), test_string,
+                                      test_string)
+                    # string -> URI -> dict -> URI -> string
+                    uri_dict = URI.from_uri_string(test_string).to_dict()
+                    self.assertEqual(URI.from_dict(uri_dict).to_uri_string(), test_string,
+                                      test_string)
+                    # URI -> dict -> URI -> string
+                    self.assertEqual(URI.from_dict(expected_uri_obj.to_dict()).to_uri_string(),
+                                      test_string, test_string)
+            except URIParseError as err:
+                print("ERROR: " + test_string)
+                raise
+
+    def test_uri_errors(self):
+        for test_str, err in parsed_uri_raises:
+            try:
+                URI.from_uri_string(test_str)
+            except URIParseError:
+                pass
+            else:
+                print("\nSuccessfully parsed invalid url: " + test_str)
+            self.assertRaises(err, URI.from_uri_string, test_str)
+
+
+class TestEncoderAndDecoder(UnitTest):
+    def test_encode_decode(self):
+        test_claim = ClaimDict.load_dict(example_010)
+        self.assertEqual(test_claim.is_certificate, False)
+        self.assertDictEqual(test_claim.claim_dict, example_010)
+        test_pb = test_claim.protobuf
+        self.assertDictEqual(ClaimDict.load_protobuf(test_pb).claim_dict, example_010)
+        self.assertEqual(test_pb.ByteSize(), ClaimDict.load_protobuf(test_pb).protobuf_len)
+        self.assertEqual(test_claim.json_len, ClaimDict.load_protobuf(test_pb).json_len)
+
+    def test_deserialize(self):
+        deserialized_claim = ClaimDict.deserialize(binascii.unhexlify(example_010_serialized))
+        self.assertDictEqual(ClaimDict.load_dict(example_010).claim_dict,
+                             deserialized_claim.claim_dict)
+
+    def test_stream_is_not_certificate(self):
+        deserialized_claim = ClaimDict.deserialize(binascii.unhexlify(example_010_serialized))
+        self.assertEqual(deserialized_claim.is_certificate, False)
+
+
+class TestISO639(UnitTest):
+    def test_alpha2(self):
+        prefixes = ['en', 'aa', 'ab', 'ae', 'af', 'ak', 'am', 'an', 'ar', 'as', 'av', 'ay', 'az',
+                    'ba', 'be', 'bg', 'bh', 'bi', 'bm', 'bn', 'bo', 'br', 'bs', 'ca', 'ce', 'ch',
+                    'co', 'cr', 'cs', 'cu', 'cv', 'cy', 'da', 'de', 'dv', 'dz', 'ee', 'el', 'eo',
+                    'es', 'et', 'eu', 'fa', 'ff', 'fi', 'fj', 'fo', 'fr', 'fy', 'ga', 'gd', 'gl',
+                    'gn', 'gu', 'gv', 'ha', 'he', 'hi', 'ho', 'hr', 'ht', 'hu', 'hy', 'hz', 'ia',
+                    'id', 'ie', 'ig', 'ii', 'ik', 'io', 'is', 'it', 'iu', 'ja', 'jv', 'ka', 'kg',
+                    'ki', 'kj', 'kk', 'kl', 'km', 'kn', 'ko', 'kr', 'ks', 'ku', 'kv', 'kw', 'ky',
+                    'la', 'lb', 'lg', 'li', 'ln', 'lo', 'lt', 'lu', 'lv', 'mg', 'mh', 'mi', 'mk',
+                    'ml', 'mn', 'mr', 'ms', 'mt', 'my', 'na', 'nb', 'nd', 'ne', 'ng', 'nl', 'nn',
+                    'no', 'nr', 'nv', 'ny', 'oc', 'oj', 'om', 'or', 'os', 'pa', 'pi', 'pl', 'ps',
+                    'pt', 'qu', 'rm', 'rn', 'ro', 'ru', 'rw', 'sa', 'sc', 'sd', 'se', 'sg', 'si',
+                    'sk', 'sl', 'sm', 'sn', 'so', 'sq', 'sr', 'ss', 'st', 'su', 'sv', 'sw', 'ta',
+                    'te', 'tg', 'th', 'ti', 'tk', 'tl', 'tn', 'to', 'tr', 'ts', 'tt', 'tw', 'ty',
+                    'ug', 'uk', 'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi', 'yo', 'za',
+                    'zh', 'zu']
+        for prefix in prefixes:
+            metadata = deepcopy(example_010)
+            metadata['stream']['metadata']['language'] = prefix
+            claim = ClaimDict.load_dict(metadata)
+            serialized = claim.serialized
+            self.assertDictEqual(metadata, dict(ClaimDict.deserialize(serialized).claim_dict))
+
+    def test_fake_alpha2(self):
+        fake_codes = ["bb", "zz"]
+        for fake_code in fake_codes:
+            metadata = deepcopy(example_010)
+            metadata['stream']['metadata']['language'] = fake_code
+            self.assertRaises(DecodeError, ClaimDict.load_dict, metadata)
+
+
+class TestMigration(UnitTest):
+    def test_migrate_to_010(self):
+        migrated_0_1_0 = migrate(example_003)
+        self.assertDictEqual(migrated_0_1_0.claim_dict, example_010)
+        self.assertEqual(migrated_0_1_0.is_certificate, False)
+
+
+class TestNIST256pSignatures(UnitTest):
+    def test_make_ecdsa_cert(self):
+        cert = ClaimDict.generate_certificate(nist256p_private_key, curve=NIST256p)
+        self.assertEqual(cert.is_certificate, True)
+        self.assertDictEqual(cert.claim_dict, nist256p_cert)
+
+    def test_validate_ecdsa_signature(self):
+        cert = ClaimDict.generate_certificate(nist256p_private_key, curve=NIST256p)
+        signed = ClaimDict.load_dict(example_010).sign(nist256p_private_key,
+                                                       claim_address_2, claim_id_1, curve=NIST256p)
+        self.assertDictEqual(signed.claim_dict, claim_010_signed_nist256p)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        self.assertEqual(signed_copy.validate_signature(claim_address_2, cert), True)
+
+    def test_remove_signature_equals_unsigned(self):
+        unsigned = ClaimDict.load_dict(example_010)
+        signed = unsigned.sign(nist256p_private_key, claim_address_1, claim_id_1, curve=NIST256p)
+        self.assertEqual(unsigned.serialized, signed.serialized_no_signature)
+
+    def test_fail_to_validate_fake_ecdsa_signature(self):
+        signed = ClaimDict.load_dict(example_010).sign(nist256p_private_key, claim_address_1,
+                                                       claim_id_1, curve=NIST256p)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        fake_key = get_signer(NIST256p).generate().private_key.to_pem()
+        fake_cert = ClaimDict.generate_certificate(fake_key, curve=NIST256p)
+        self.assertRaises(ecdsa.keys.BadSignatureError, signed_copy.validate_signature,
+                          claim_address_2, fake_cert)
+
+    def test_fail_to_validate_ecdsa_sig_for_altered_claim(self):
+        cert = ClaimDict.generate_certificate(nist256p_private_key, curve=NIST256p)
+        altered = ClaimDict.load_dict(example_010).sign(nist256p_private_key, claim_address_1,
+                                                        claim_id_1, curve=NIST256p)
+        sd_hash = altered['stream']['source']['source']
+        altered['stream']['source']['source'] = sd_hash[::-1]
+        altered_copy = ClaimDict.load_dict(altered.claim_dict)
+        self.assertRaises(ecdsa.keys.BadSignatureError, altered_copy.validate_signature,
+                          claim_address_1, cert)
+
+
+class TestNIST384pSignatures(UnitTest):
+    def test_make_ecdsa_cert(self):
+        cert = ClaimDict.generate_certificate(nist384p_private_key, curve=NIST384p)
+        self.assertEqual(cert.is_certificate, True)
+        self.assertDictEqual(cert.claim_dict, nist384p_cert)
+
+    def test_validate_ecdsa_signature(self):
+        cert = ClaimDict.generate_certificate(nist384p_private_key, curve=NIST384p)
+        signed = ClaimDict.load_dict(example_010).sign(nist384p_private_key,
+                                                       claim_address_2, claim_id_1, curve=NIST384p)
+        self.assertDictEqual(signed.claim_dict, claim_010_signed_nist384p)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        self.assertEqual(signed_copy.validate_signature(claim_address_2, cert), True)
+
+    def test_remove_signature_equals_unsigned(self):
+        unsigned = ClaimDict.load_dict(example_010)
+        signed = unsigned.sign(nist384p_private_key, claim_address_1, claim_id_1, curve=NIST384p)
+        self.assertEqual(unsigned.serialized, signed.serialized_no_signature)
+
+    def test_fail_to_validate_fake_ecdsa_signature(self):
+        signed = ClaimDict.load_dict(example_010).sign(nist384p_private_key, claim_address_1,
+                                                       claim_id_1, curve=NIST384p)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        fake_key = get_signer(NIST384p).generate().private_key.to_pem()
+        fake_cert = ClaimDict.generate_certificate(fake_key, curve=NIST384p)
+        self.assertRaises(ecdsa.keys.BadSignatureError, signed_copy.validate_signature,
+                          claim_address_2, fake_cert)
+
+    def test_fail_to_validate_ecdsa_sig_for_altered_claim(self):
+        cert = ClaimDict.generate_certificate(nist384p_private_key, curve=NIST384p)
+        altered = ClaimDict.load_dict(example_010).sign(nist384p_private_key, claim_address_1,
+                                                        claim_id_1, curve=NIST384p)
+        sd_hash = altered['stream']['source']['source']
+        altered['stream']['source']['source'] = sd_hash[::-1]
+        altered_copy = ClaimDict.load_dict(altered.claim_dict)
+        self.assertRaises(ecdsa.keys.BadSignatureError, altered_copy.validate_signature,
+                          claim_address_1, cert)
+
+
+class TestSECP256k1Signatures(UnitTest):
+    def test_make_ecdsa_cert(self):
+        cert = ClaimDict.generate_certificate(secp256k1_private_key, curve=SECP256k1)
+        self.assertEqual(cert.is_certificate, True)
+        self.assertDictEqual(cert.claim_dict, secp256k1_cert)
+
+    def test_validate_ecdsa_signature(self):
+        cert = ClaimDict.generate_certificate(secp256k1_private_key, curve=SECP256k1)
+        self.assertDictEqual(cert.claim_dict, secp256k1_cert)
+        signed = ClaimDict.load_dict(example_010).sign(secp256k1_private_key, claim_address_2,
+                                                       claim_id_1, curve=SECP256k1)
+        self.assertDictEqual(signed.claim_dict, claim_010_signed_secp256k1)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        self.assertEqual(signed_copy.validate_signature(claim_address_2, cert), True)
+
+    def test_fail_to_sign_with_no_claim_address(self):
+        cert = ClaimDict.generate_certificate(secp256k1_private_key, curve=SECP256k1)
+        self.assertDictEqual(cert.claim_dict, secp256k1_cert)
+        self.assertRaises(Exception, ClaimDict.load_dict(example_010).sign, secp256k1_private_key,
+                          None, claim_id_1, curve=SECP256k1)
+
+    def test_fail_to_validate_with_no_claim_address(self):
+        cert = ClaimDict.generate_certificate(secp256k1_private_key, curve=SECP256k1)
+        self.assertDictEqual(cert.claim_dict, secp256k1_cert)
+        signed = ClaimDict.load_dict(example_010).sign(secp256k1_private_key, claim_address_2,
+                                                       claim_id_1, curve=SECP256k1)
+        self.assertDictEqual(signed.claim_dict, claim_010_signed_secp256k1)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        self.assertRaises(Exception, signed_copy.validate_signature, None, cert)
+
+    def test_remove_signature_equals_unsigned(self):
+        unsigned = ClaimDict.load_dict(example_010)
+        signed = unsigned.sign(secp256k1_private_key, claim_address_1, claim_id_1, curve=SECP256k1)
+        self.assertEqual(unsigned.serialized, signed.serialized_no_signature)
+
+    def test_fail_to_validate_fake_ecdsa_signature(self):
+        signed = ClaimDict.load_dict(example_010).sign(secp256k1_private_key, claim_address_1,
+                                                       claim_id_1, curve=SECP256k1)
+        signed_copy = ClaimDict.load_protobuf(signed.protobuf)
+        fake_key = get_signer(SECP256k1).generate().private_key.to_pem()
+        fake_cert = ClaimDict.generate_certificate(fake_key, curve=SECP256k1)
+        self.assertRaises(ecdsa.keys.BadSignatureError, signed_copy.validate_signature,
+                          claim_address_2, fake_cert)
+
+    def test_fail_to_validate_ecdsa_sig_for_altered_claim(self):
+        cert = ClaimDict.generate_certificate(secp256k1_private_key, curve=SECP256k1)
+        altered = ClaimDict.load_dict(example_010).sign(secp256k1_private_key, claim_address_1,
+                                                        claim_id_1, curve=SECP256k1)
+        sd_hash = altered['stream']['source']['source']
+        altered['stream']['source']['source'] = sd_hash[::-1]
+        altered_copy = ClaimDict.load_dict(altered.claim_dict)
+        self.assertRaises(ecdsa.keys.BadSignatureError, altered_copy.validate_signature,
+                          claim_address_1, cert)
+
+
+class TestMetadata(UnitTest):
+    def test_fail_with_fake_sd_hash(self):
+        claim = deepcopy(example_010)
+        sd_hash = claim['stream']['source']['source'][:-2]
+        claim['stream']['source']['source'] = sd_hash
+        self.assertRaises(AssertionError, ClaimDict.load_dict, claim)
+
+
+class TestSmartDecode(UnitTest):
+    def test_hex_decode(self):
+        self.assertEqual(decoded_hex_encoded_003, smart_decode(hex_encoded_003).claim_dict)
+
+    def test_binary_decode(self):
+        self.assertEqual(expected_binary_claim_decoded, smart_decode(binary_claim).claim_dict)
+
+    def test_smart_decode_raises(self):
+        with self.assertRaises(TypeError):
+            smart_decode(1)
+
+        with self.assertRaises(DecodeError):
+            smart_decode("aaab")
+
+        with self.assertRaises(DecodeError):
+            smart_decode("{'bogus_dict':1}")
+
+
+class TestMainnetAddressValidation(UnitTest):
+    def test_mainnet_address_encode_decode(self):
+        valid_addr_hex = "55be482f953ed0feda4fc5c4d012681b6119274993dc96bf10"
+        self.assertEqual(encode_address(binascii.unhexlify(valid_addr_hex)),
+                         b"bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHyR")
+        self.assertEqual(decode_address("bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHyR"),
+                         binascii.unhexlify(valid_addr_hex))
+
+    def test_mainnet_address_encode_error(self):
+        invalid_prefix =   "54be482f953ed0feda4fc5c4d012681b6119274993dc96bf10"
+        invalid_checksum = "55be482f953ed0feda4fc5c4d012681b6119274993dc96bf11"
+        invalid_length =   "55482f953ed0feda4fc5c4d012681b6119274993dc96bf10"
+
+        with self.assertRaises(InvalidAddress):
+            encode_address(binascii.unhexlify(invalid_prefix))
+            encode_address(binascii.unhexlify(invalid_checksum))
+            encode_address(binascii.unhexlify(invalid_length))
+
+    def test_mainnet_address_decode_error(self):
+        with self.assertRaises(InvalidAddress):
+            decode_address("bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHR")
+        with self.assertRaises(InvalidAddress):
+            decode_address("mzGSynizDwSgURdnFjosZwakSVuZrdE8V4")
+
+
+class TestRegtestAddressValidation(UnitTest):
+    def setUp(self):
+        schema.BLOCKCHAIN_NAME = "lbrycrd_regtest"
+
+    def tearDown(self):
+        schema.BLOCKCHAIN_NAME = "lbrycrd_main"
+
+    def test_regtest_address_encode_decode(self):
+        valid_addr_hex = "6fcdac187757dbf05500f613ada6fdd953d59b9acbf3c9343f"
+        self.assertEqual(encode_address(binascii.unhexlify(valid_addr_hex)),
+                         b"mzGSynizDwSgURdnFjosZwakSVuZrdE8V4")
+        self.assertEqual(decode_address("mzGSynizDwSgURdnFjosZwakSVuZrdE8V4"),
+                         binascii.unhexlify(valid_addr_hex))
+
+    def test_regtest_address_encode_error(self):
+        invalid_prefix =   "6dcdac187757dbf05500f613ada6fdd953d59b9acbf3c9343f"
+        invalid_checksum = "6fcdac187757dbf05500f613ada6fdd953d59b9acbf3c9343d"
+        invalid_length =   "6fcdac187757dbf05500f613ada6fdd953d59b9acbf3c934"
+
+        with self.assertRaises(InvalidAddress):
+            encode_address(binascii.unhexlify(invalid_prefix))
+            encode_address(binascii.unhexlify(invalid_checksum))
+            encode_address(binascii.unhexlify(invalid_length))
+
+    def test_regtest_address_decode_error(self):
+        with self.assertRaises(InvalidAddress):
+            decode_address("bW5PZEvEBNPQRVhwpYXSjabFgbSw1oaHyR")
+        with self.assertRaises(InvalidAddress):
+            decode_address("mzGSynizDwSgURdnFjosZwakSVuZrdE8V5")
+
+
+class TestInvalidCertificateCurve(UnitTest):
+    def test_invalid_cert_curve(self):
+        with self.assertRaises(Exception):
+            ClaimDict.load_dict(malformed_secp256k1_cert)
+
+
+class TestValidatePrivateKey(UnitTest):
+    def test_valid_private_key_for_cert(self):
+        cert_claim = ClaimDict.load_dict(secp256k1_cert)
+        self.assertEqual(cert_claim.validate_private_key(secp256k1_private_key, claim_id_1),
+                         True)
+
+    def test_fail_to_load_wrong_private_key_for_cert(self):
+        cert_claim = ClaimDict.load_dict(secp256k1_cert)
+        self.assertEqual(cert_claim.validate_private_key(nist256p_private_key, claim_id_1),
+                         False)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_cli.py b/tests/unit/test_cli.py
index 2105b4ec5..772b3ae09 100644
--- a/tests/unit/test_cli.py
+++ b/tests/unit/test_cli.py
@@ -2,8 +2,8 @@ import contextlib
 from io import StringIO
 from twisted.trial import unittest
 
-from lbrynet.cli import normalize_value, main
-from lbrynet.core.system_info import get_platform
+from lbrynet.extras.cli import normalize_value, main
+from lbrynet.extras.system_info import get_platform
 
 
 class CLITest(unittest.TestCase):
@@ -67,7 +67,7 @@ class CLITest(unittest.TestCase):
             main(['version'])
         self.assertEqual(
             actual_output.getvalue().strip(),
-            "lbrynet {lbrynet_version}".format(**get_platform(get_ip=False))
+            "lbrynet {lbrynet_version}".format(**get_platform())
         )
 
     def test_invalid_command(self):
diff --git a/tests/unit/test_conf.py b/tests/unit/test_conf.py
index ec5162ecc..5ab939b6d 100644
--- a/tests/unit/test_conf.py
+++ b/tests/unit/test_conf.py
@@ -5,7 +5,7 @@ import tempfile
 from unittest import skipIf
 from twisted.trial import unittest
 from lbrynet import conf
-from lbrynet.core.Error import InvalidCurrencyError
+from lbrynet.p2p.Error import InvalidCurrencyError
 
 
 class SettingsTest(unittest.TestCase):
diff --git a/tests/unit/test_customLogger.py b/tests/unit/test_customLogger.py
index 051b20185..66c4aa572 100644
--- a/tests/unit/test_customLogger.py
+++ b/tests/unit/test_customLogger.py
@@ -1,16 +1,16 @@
 from io import StringIO
 import logging
+from unittest import mock
+from unittest import skipIf
 
-import mock
-import unittest
 from twisted.internet import defer
-from twisted import trial
+from twisted.trial import unittest
 
 from lbrynet import custom_logger
-from tests.util import is_android
+from tests.test_utils import is_android
 
 
-class TestLogger(trial.unittest.TestCase):
+class TestLogger(unittest.TestCase):
     def raiseError(self):
         raise Exception('terrible things happened')
 
@@ -28,7 +28,7 @@ class TestLogger(trial.unittest.TestCase):
         handler.setFormatter(logging.Formatter("%(filename)s:%(lineno)d - %(message)s"))
         self.log.addHandler(handler)
 
-    @unittest.skipIf(is_android(),
+    @skipIf(is_android(),
                      'Test cannot pass on Android because the tests package is compiled '
                      'which results in a different method call stack')
     def test_can_log_failure(self):
diff --git a/tests/unit/wallet/test_account.py b/tests/unit/wallet/test_account.py
index 30bf7a35b..92a8a7fb3 100644
--- a/tests/unit/wallet/test_account.py
+++ b/tests/unit/wallet/test_account.py
@@ -1,9 +1,9 @@
-from orchstr8.testcase import AsyncioTestCase
-from torba.wallet import Wallet
+from torba.testcase import AsyncioTestCase
+from torba.client.wallet import Wallet
 
-from lbrynet.wallet.ledger import MainNetLedger, WalletDatabase
-from lbrynet.wallet.header import Headers
-from lbrynet.wallet.account import Account
+from lbrynet.extras.wallet.ledger import MainNetLedger, WalletDatabase
+from lbrynet.extras.wallet.header import Headers
+from lbrynet.extras.wallet.account import Account
 
 
 class TestAccount(AsyncioTestCase):
diff --git a/tests/unit/wallet/test_claim_proofs.py b/tests/unit/wallet/test_claim_proofs.py
index 158ea33f7..22e7377cf 100644
--- a/tests/unit/wallet/test_claim_proofs.py
+++ b/tests/unit/wallet/test_claim_proofs.py
@@ -1,8 +1,8 @@
 import unittest
 from binascii import hexlify, unhexlify
 
-from lbrynet.wallet.claim_proofs import get_hash_for_outpoint, verify_proof
-from lbryschema.hashing import double_sha256
+from lbrynet.extras.wallet.claim_proofs import get_hash_for_outpoint, verify_proof
+from lbrynet.schema.hashing import double_sha256
 
 
 class ClaimProofsTestCase(unittest.TestCase):
diff --git a/tests/unit/wallet/test_dewies.py b/tests/unit/wallet/test_dewies.py
index a29a77680..8c8afbcbd 100644
--- a/tests/unit/wallet/test_dewies.py
+++ b/tests/unit/wallet/test_dewies.py
@@ -1,6 +1,6 @@
 import unittest
 
-from lbrynet.wallet.dewies import lbc_to_dewies as l2d, dewies_to_lbc as d2l
+from lbrynet.extras.wallet.dewies import lbc_to_dewies as l2d, dewies_to_lbc as d2l
 
 
 class TestDeweyConversion(unittest.TestCase):
diff --git a/tests/unit/wallet/test_headers.py b/tests/unit/wallet/test_headers.py
index 872c5bac8..7b082b60b 100644
--- a/tests/unit/wallet/test_headers.py
+++ b/tests/unit/wallet/test_headers.py
@@ -1,9 +1,9 @@
 from binascii import unhexlify
 
-from orchstr8.testcase import AsyncioTestCase
-from torba.util import ArithUint256
+from torba.testcase import AsyncioTestCase
+from torba.client.util import ArithUint256
 
-from lbrynet.wallet.ledger import Headers
+from lbrynet.extras.wallet.ledger import Headers
 
 
 class TestHeaders(AsyncioTestCase):
diff --git a/tests/unit/wallet/test_ledger.py b/tests/unit/wallet/test_ledger.py
index 5cd097696..0bcad4ce3 100644
--- a/tests/unit/wallet/test_ledger.py
+++ b/tests/unit/wallet/test_ledger.py
@@ -1,9 +1,9 @@
-from orchstr8.testcase import AsyncioTestCase
-from torba.wallet import Wallet
+from torba.testcase import AsyncioTestCase
+from torba.client.wallet import Wallet
 
-from lbrynet.wallet.account import Account
-from lbrynet.wallet.transaction import Transaction, Output, Input
-from lbrynet.wallet.ledger import MainNetLedger
+from lbrynet.extras.wallet.account import Account
+from lbrynet.extras.wallet.transaction import Transaction, Output, Input
+from lbrynet.extras.wallet.ledger import MainNetLedger
 
 
 class LedgerTestCase(AsyncioTestCase):
@@ -31,15 +31,17 @@ class BasicAccountingTests(LedgerTestCase):
 
         tx = Transaction(is_verified=True)\
             .add_outputs([Output.pay_pubkey_hash(100, hash160)])
+        await self.ledger.db.insert_transaction(tx)
         await self.ledger.db.save_transaction_io(
-            'insert', tx, address, hash160, '{}:{}:'.format(tx.id, 1)
+            tx, address, hash160, '{}:{}:'.format(tx.id, 1)
         )
         self.assertEqual(await self.account.get_balance(), 100)
 
         tx = Transaction(is_verified=True)\
             .add_outputs([Output.pay_claim_name_pubkey_hash(100, 'foo', b'', hash160)])
+        await self.ledger.db.insert_transaction(tx)
         await self.ledger.db.save_transaction_io(
-            'insert', tx, address, hash160, '{}:{}:'.format(tx.id, 1)
+            tx, address, hash160, '{}:{}:'.format(tx.id, 1)
         )
         self.assertEqual(await self.account.get_balance(), 100)  # claim names don't count towards balance
         self.assertEqual(await self.account.get_balance(include_claims=True), 200)
diff --git a/tests/unit/wallet/test_script.py b/tests/unit/wallet/test_script.py
index 5954d61e6..b0d36d4ad 100644
--- a/tests/unit/wallet/test_script.py
+++ b/tests/unit/wallet/test_script.py
@@ -1,7 +1,7 @@
 import unittest
 from binascii import hexlify, unhexlify
 
-from lbrynet.wallet.script import OutputScript
+from lbrynet.extras.wallet.script import OutputScript
 
 
 class TestPayClaimNamePubkeyHash(unittest.TestCase):
diff --git a/tests/unit/wallet/test_transaction.py b/tests/unit/wallet/test_transaction.py
index f3359ac22..1fb4b25e0 100644
--- a/tests/unit/wallet/test_transaction.py
+++ b/tests/unit/wallet/test_transaction.py
@@ -1,12 +1,12 @@
 import unittest
 from binascii import hexlify, unhexlify
 
-from orchstr8.testcase import AsyncioTestCase
-from torba.constants import CENT, COIN, NULL_HASH32
-from torba.wallet import Wallet
+from torba.testcase import AsyncioTestCase
+from torba.client.constants import CENT, COIN, NULL_HASH32
+from torba.client.wallet import Wallet
 
-from lbrynet.wallet.ledger import MainNetLedger
-from lbrynet.wallet.transaction import Transaction, Output, Input
+from lbrynet.extras.wallet import MainNetLedger
+from lbrynet.extras.wallet.transaction import Transaction, Output, Input
 
 
 FEE_PER_BYTE = 50
diff --git a/tox.ini b/tox.ini
index 9f6ad535b..4d186c662 100644
--- a/tox.ini
+++ b/tox.ini
@@ -5,19 +5,20 @@ envlist = py37-integration
 deps =
   coverage
   ../torba
-  ../lbryschema
-  ../electrumx
-  ../lbryumx
-  ../orchstr8
 extras = test
 changedir = {toxinidir}/tests
 setenv =
   HOME=/tmp
-  LEDGER=lbrynet.wallet
+  TORBA_LEDGER=lbrynet.extras.wallet
 commands =
   orchstr8 download
   coverage run -p --source={envsitepackagesdir}/lbrynet -m unittest integration.wallet.test_transactions.BasicTransactionTest
   coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.cli
   coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.AccountManagement
-  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.PublishCommand
+  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.ClaimManagement.test_update_claim_holding_address
+  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.ClaimManagement.test_publishing_checks_all_accounts_for_certificate
+  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.ClaimManagement.test_updating_claim_includes_claim_value_in_balance_check
+  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.ClaimManagement.test_abandoning_claim_at_loss
+  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.ClaimManagement.test_abandoned_channel_with_signed_claims
+  coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.ClaimManagement.test_regular_supports_and_tip_supports
   coverage run -p --source={envsitepackagesdir}/lbrynet -m twisted.trial --reactor=asyncio integration.wallet.test_commands.EpicAdventuresOfChris45