Revert "TEMP: Try python 3.8."

This reverts commit 8def4d5177.
Bump python_requires >= 3.8.
2023-04-03 13:34:36 -04:00 · 2023-04-03 13:34:36 -04:00 · 2023-04-03 13:34:36 -04:00 · 2023-04-03 13:34:36 -04:00 · 2023-04-03 13:34:36 -04:00 · 2023-04-03 13:34:36 -04:00
449 changed files with 31985 additions and 33742 deletions
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@ -0,0 +1,206 @@
 name: ci
 on: ["push", "pull_request", "workflow_dispatch"]
 jobs:
  lint:
    name: lint
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.9'
      - name: extract pip cache
        uses: actions/cache@v3
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-${{ hashFiles('setup.py') }}
          restore-keys: ${{ runner.os }}-pip-
      - run: pip install --user --upgrade pip wheel
      - run: pip install -e .[lint]
      - run: make lint
  tests-unit:
    name: "tests / unit"
    strategy:
      matrix:
        os:
          - ubuntu-20.04
          - macos-latest
          - windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.9'
      - name: set pip cache dir
        shell: bash
        run: echo "PIP_CACHE_DIR=$(pip cache dir)" >> $GITHUB_ENV
      - name: extract pip cache
        uses: actions/cache@v3
        with:
          path: ${{ env.PIP_CACHE_DIR }}
          key: ${{ runner.os }}-pip-${{ hashFiles('setup.py') }}
          restore-keys: ${{ runner.os }}-pip-
      - id: os-name
        uses: ASzc/change-string-case-action@v5
        with:
          string: ${{ runner.os }}
      - run: python -m pip install --user --upgrade pip wheel
      - if: startsWith(runner.os, 'linux')
        run: pip install -e .[test]
      - if: startsWith(runner.os, 'linux')
        env:
          HOME: /tmp
        run: make test-unit-coverage
      - if: startsWith(runner.os, 'linux') != true
        run: pip install -e .[test]
      - if: startsWith(runner.os, 'linux') != true
        env:
          HOME: /tmp
        run: coverage run --source=lbry -m unittest tests/unit/test_conf.py
      - name: submit coverage report
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          COVERALLS_FLAG_NAME: tests-unit-${{ steps.os-name.outputs.lowercase }}
          COVERALLS_PARALLEL: true
        run: |
          pip install coveralls
          coveralls --service=github
  tests-integration:
    name: "tests / integration"
    runs-on: ubuntu-20.04
    strategy:
      matrix:
        test:
          - datanetwork
          - blockchain
          - claims
          - takeovers
          - transactions
          - other
    steps:
      - name: Configure sysctl limits
        run: |
          sudo swapoff -a
          sudo sysctl -w vm.swappiness=1
          sudo sysctl -w fs.file-max=262144
          sudo sysctl -w vm.max_map_count=262144
      - name: Runs Elasticsearch
        uses: elastic/elastic-github-actions/elasticsearch@master
        with:
          stack-version: 7.12.1
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.9'
      - if: matrix.test == 'other'
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends ffmpeg
      - name: extract pip cache
        uses: actions/cache@v3
        with:
          path: ./.tox
          key: tox-integration-${{ matrix.test }}-${{ hashFiles('setup.py') }}
          restore-keys: txo-integration-${{ matrix.test }}-
      - run: pip install tox coverage coveralls
      - if: matrix.test == 'claims'
        run: rm -rf .tox
      - run: tox -e ${{ matrix.test }}
      - name: submit coverage report
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          COVERALLS_FLAG_NAME: tests-integration-${{ matrix.test }}
          COVERALLS_PARALLEL: true
        run: |
          coverage combine tests
          coveralls --service=github
  coverage:
    needs: ["tests-unit", "tests-integration"]
    runs-on: ubuntu-20.04
    steps:
      - name: finalize coverage report submission
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          pip install coveralls
          coveralls --service=github --finish
  build:
    needs: ["lint", "tests-unit", "tests-integration"]
    name: "build / binary"
    strategy:
      matrix:
        os:
          - ubuntu-20.04
          - macos-latest
          - windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.9'
      - id: os-name
        uses: ASzc/change-string-case-action@v5
        with:
          string: ${{ runner.os }}
      - name: set pip cache dir
        shell: bash
        run: echo "PIP_CACHE_DIR=$(pip cache dir)" >> $GITHUB_ENV
      - name: extract pip cache
        uses: actions/cache@v3
        with:
          path: ${{ env.PIP_CACHE_DIR }}
          key: ${{ runner.os }}-pip-${{ hashFiles('setup.py') }}
          restore-keys: ${{ runner.os }}-pip-
      - run: pip install pyinstaller==4.6
      - run: pip install -e .
      - if: startsWith(github.ref, 'refs/tags/v')
        run: python docker/set_build.py
      - if: startsWith(runner.os, 'linux') || startsWith(runner.os, 'mac')
        name: Build & Run (Unix)
        run: |
          pyinstaller --onefile --name lbrynet lbry/extras/cli.py
          dist/lbrynet --version
      - if: startsWith(runner.os, 'windows')
        name: Build & Run (Windows)
        run: |
          pip install pywin32==301
          pyinstaller --additional-hooks-dir=scripts/. --icon=icons/lbry256.ico --onefile --name lbrynet lbry/extras/cli.py
          dist/lbrynet.exe --version
      - uses: actions/upload-artifact@v3
        with:
          name: lbrynet-${{ steps.os-name.outputs.lowercase }}
          path: dist/
  release:
    name: "release"
    if: startsWith(github.ref, 'refs/tags/v')
    needs: ["build"]
    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v1
      - uses: actions/download-artifact@v2
      - name: upload binaries
        env:
          GITHUB_TOKEN: ${{ secrets.RELEASE_API_TOKEN }}
        run: |
          pip install githubrelease
          chmod +x lbrynet-macos/lbrynet
          chmod +x lbrynet-linux/lbrynet
          zip --junk-paths lbrynet-mac.zip lbrynet-macos/lbrynet
          zip --junk-paths lbrynet-linux.zip lbrynet-linux/lbrynet
          zip --junk-paths lbrynet-windows.zip lbrynet-windows/lbrynet.exe
          ls -lh
          githubrelease release lbryio/lbry-sdk info ${GITHUB_REF#refs/tags/}
          githubrelease asset lbryio/lbry-sdk upload ${GITHUB_REF#refs/tags/} \
            lbrynet-mac.zip lbrynet-linux.zip lbrynet-windows.zip
          githubrelease release lbryio/lbry-sdk publish ${GITHUB_REF#refs/tags/}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -0,0 +1,22 @@
 name: slack
 on:
  release:
    types: [published]
 jobs:
  release:
    name: "slack notification"
    runs-on: ubuntu-20.04
    steps:
      - uses: LoveToKnow/slackify-markdown-action@v1.0.0
        id: markdown
        with:
          text: "There is a new SDK release: ${{github.event.release.html_url}}\n${{ github.event.release.body }}"
      - uses: slackapi/slack-github-action@v1.14.0
        env:
          CHANGELOG: '<!channel> ${{ steps.markdown.outputs.text }}'
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_RELEASE_BOT_WEBHOOK }}
        with:
          payload: '{"type": "mrkdwn", "text": ${{ toJSON(env.CHANGELOG) }} }'
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,22 @@
 /.idea
 /.DS_Store
 /build
 /dist
 /.tox
 /.coverage*
 /lbry-venv
 /venv
 /lbry/blockchain
 lbry.egg-info
 __pycache__
 _trial_temp/
 trending*.log
 /tests/integration/claims/files
 /tests/.coverage.*
 /lbry/wallet/bin
 /.vscode
 /.gitignore
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,190 +0,0 @@
 default:
  image: python:3.7
 #cache:
 #  directories:
 #    - $HOME/venv
 #    - $HOME/.cache/pip
 #    - $HOME/Library/Caches/pip
 #    - $HOME/Library/Caches/Homebrew
 #    - $TRAVIS_BUILD_DIR/.tox
 stages:
  - test
  - build
  - release
 test:lint:
  stage: test
  script:
    - make install tools
    - make lint
 test:lbry-unit:
  stage: test
  script:
    - make install tools
    - cd lbry && HOME=/tmp coverage run -p --source=lbry -m unittest discover -vv tests.unit
 test:lbry-integ:
  stage: test
  script:
    - pip install coverage tox-travis
    - cd lbry && tox
 .torba-tests: &torba_tests
  stage: test
  script:
    - pip install coverage tox-travis
    - cd torba && tox
 test:torba-unit:
  before_script:
    - export TESTTYPE=unit
  <<: *torba_tests
 test:torba-integ:
  before_script:
    - export TESTTYPE=integration
  <<: *torba_tests
 test:json-api:
  stage: test
  script:
    - make install tools
    - cd lbry && HOME=/tmp coverage run -p --source=lbry scripts/generate_json_api.py
 .build:
  stage: build
  artifacts:
    expire_in: 1 day
    paths:
      - lbrynet-${OS}.zip
  script:
    - pip install pyinstaller
    - pip install -e torba/.
    - python3.7 docker/set_build.py
    - pip install -e lbry/.
    - pyinstaller --onefile --name lbrynet lbry/lbry/extras/cli.py
    - chmod +x dist/lbrynet
    - zip --junk-paths ${CI_PROJECT_DIR}/lbrynet-${OS}.zip dist/lbrynet  # gitlab expects artifacts to be in $CI_PROJECT_DIR
    - openssl dgst -sha256 ${CI_PROJECT_DIR}/lbrynet-${OS}.zip | egrep -o [0-9a-f]+$ # get sha256 of asset. works on mac and ubuntu
    - dist/lbrynet --version
 build:linux:
  extends: .build
  image: ubuntu:18.04  # cant use python3.7 image - binary won't run on ubuntu
  variables:
    OS: linux
  before_script:
    - apt-get update
    - apt-get install -y --no-install-recommends software-properties-common zip curl build-essential
    - add-apt-repository -y ppa:deadsnakes/ppa
    - apt-get install -y --no-install-recommends python3.7-dev python3-setuptools python3-wheel
    - python3.7 <(curl -q https://bootstrap.pypa.io/get-pip.py) # make sure we get pip with python3.7
 build:mac:
  extends: .build
  tags: [macos] # makes gitlab use the mac runner
  variables:
    OS: mac
    GIT_DEPTH: 5
    VENV: /tmp/gitlab-lbry-sdk-venv
  before_script:
 #    - brew upgrade python || true
    - python3 --version | grep -q '^Python 3\.7\.' # dont upgrade python on every run. just make sure we're on the right Python
 #    - pip3 install --user --upgrade pip virtualenv
    - pip3 --version | grep -q '\(python 3\.7\)'
    - virtualenv --python=python3.7 "${VENV}"
    - source "${VENV}/bin/activate"
  after_script:
    - rm -rf "${VENV}"
 build:windows:
  extends: .build
  tags: [windows] # makes gitlab use the windows runner
  variables:
    OS: windows
    GIT_DEPTH: 5
  before_script:
    - ./docker/install_choco.ps1
    - choco install -y --x86 python3 7zip checksum
 #    - python --version | findstr /B "Python 3\.7\." # dont upgrade python on every run. just make sure we're on the right Python
 #    - pip --version | findstr /E '\(python 3\.7\)'
    - pip install virtualenv pywin32
    - virtualenv venv
    - venv/Scripts/activate.ps1
  after_script:
    - rmdir -Recurse venv
  script:
    - pip install pyinstaller
    - pip install -e torba/.
    - python docker/set_build.py
    - pip install -e lbry/.
    - pyinstaller --additional-hooks-dir=lbry/scripts/. --icon=lbry/icons/lbry256.ico -F -n lbrynet lbry/lbry/extras/cli.py
    - 7z a -tzip $env:CI_PROJECT_DIR/lbrynet-${OS}.zip dist/lbrynet.exe
    - checksum --type=sha256 --file=$env:CI_PROJECT_DIR/lbrynet-${OS}.zip
    - dist/lbrynet.exe --version
 # s3 = upload asset to s3 (build.lbry.io)
 # could be done by making it a yaml alias and putting it right into the build step. that way if one OS fails, the others still get uploaded
 .s3:
  stage: release
  variables:
    GIT_STRATEGY: none
  script:
    - pip install awscli
    - S3_PATH="daemon/gitlab-build-${CI_PIPELINE_ID}_commit-${CI_COMMIT_SHA:0:7}$( if [ ! -z ${CI_COMMIT_TAG} ]; then echo _tag-${CI_COMMIT_TAG}; else echo _branch-${CI_COMMIT_REF_NAME}; fi )"
    - AWS_ACCESS_KEY_ID=${ARTIFACTS_KEY} AWS_SECRET_ACCESS_KEY=${ARTIFACTS_SECRET} AWS_REGION=${ARTIFACTS_REGION}
      aws s3 cp lbrynet-${OS}.zip s3://${ARTIFACTS_BUCKET}/${S3_PATH}/lbrynet-${OS}.zip
 s3:linux:
  extends: .s3
  variables: {OS: linux}
  dependencies: ["build:linux"]
 s3:mac:
  extends: .s3
  variables: {OS: mac}
  dependencies: ["build:mac"]
 s3:windows:
  extends: .s3
  variables: {OS: windows}
  dependencies: ["build:windows"]
 # release = upload assets to github when there's a tagged release
 .release:
  stage: release
  rules:
    - if: '$CI_COMMIT_TAG =~ /^v[0-9\.]+$/'
      when: on_success
  variables:
    GIT_STRATEGY: none
  script:
    - pip install githubrelease
    - githubrelease --no-progress --github-token ${GITHUB_CI_USER_ACCESS_TOKEN} asset lbryio/lbry-sdk upload ${CI_COMMIT_TAG} lbrynet-${OS}.zip
 release:linux:
  extends: .release
  variables: {OS: linux}
  dependencies: ["build:linux"]
 release:mac:
  extends: .release
  variables: {OS: mac}
  dependencies: ["build:mac"]
 release:windows:
  extends: .release
  variables: {OS: windows}
  dependencies: ["build:windows"]
--- a/.travis.yml
+++ b/.travis.yml
@ -1,142 +0,0 @@
 dist: xenial
 language: python
 python: "3.7"
 jobs:
  include:
    - stage: code quality
      name: "pylint & mypy"
      install:
        - make install tools
      script: make lint
    - stage: test
      name: "LBRY Unit Tests"
      install:
        - make install tools
      script:
        - cd lbry && HOME=/tmp coverage run -p --source=lbry -m unittest discover -vv tests.unit
      after_success:
        - coverage combine lbry/
    - name: "LBRY Integration Tests"
      install:
        - pip install coverage tox-travis
        - sudo mount -o mode=1777,nosuid,nodev -t tmpfs tmpfs /tmp
      script: cd lbry && tox
      after_success:
        - coverage combine lbry
    - &torba-tests
      name: "Torba Unit Tests"
      env: TESTTYPE=unit
      install:
        - pip install coverage tox-travis
      script: cd torba && tox
      after_success:
        - coverage combine torba/tests
    - <<: *torba-tests
      name: "Torba Integration Tests"
      env: TESTTYPE=integration
    - name: "Run Examples"
      install:
        - make install tools
      script:
        - cd lbry && HOME=/tmp coverage run -p --source=lbry scripts/generate_json_api.py
      after_success:
        - coverage combine lbry
    - &build
      stage: build
      name: "Linux"
      env: OS=linux
      install:
        - pip install pyinstaller awscli
        - python docker/set_build.py
        - pip install -e torba/.
        - pip install -e lbry/.
      script:
        - pyinstaller -F -n lbrynet lbry/lbry/extras/cli.py
        - chmod +x dist/lbrynet
        - zip --junk-paths lbrynet-${OS}.zip dist/lbrynet
        - shasum -a 256 -b lbrynet-${OS}.zip
        - dist/lbrynet --version
      after_success:
        - aws configure set aws_access_key_id $ARTIFACTS_KEY
        - aws configure set aws_secret_access_key $ARTIFACTS_SECRET
        - aws configure set region us-east-1
        - export S3_PATH="daemon/build-${TRAVIS_BUILD_NUMBER}_commit-${TRAVIS_COMMIT:0:7}_branch-${TRAVIS_BRANCH}$([ ! -z ${TRAVIS_TAG} ] && echo _tag-${TRAVIS_TAG})"
        - aws s3 cp lbrynet-${OS}.zip s3://build.lbry.io/${S3_PATH}/lbrynet-${OS}.zip
 #      deploy:
 #        provider: releases
 #        api_key:
 #          secure: "unnR+aSJ1937Cl1PyBBZzGuZvV5W5TGcXELhXTgyOeeI6FgO/j80qmbNxJDA7qdFH/hvVicQFWoflhZu2dxN5rYP5BQJW3q3XoOLY3XAc1s1vicFkwqn3TIfdFiJTz+/D9eBUBBhHKeYFxm3M+thvklTLgjKl6fflh14NfGuNTevK9yQke8wewW3f9UmFTo1qNOPF1OsTZRbwua6oQYa59P+KukoPt4Dsu1VtILtTkj7hfEsUL79cjotwO3gkhYftxbl/xeDSZWOt+9Nhb8ZKmQG/uDx4JiTMm5lWRk4QB7pUujZ1CftxCYWz/lJx9nuJpdCOgP624tcHymErNlD+vGLwMTNslcXGYkAJH6xvGyxBJ+Obc8vRVnZbRM26BfH34TcPK1ueRxHSrDUbzMIIUsgcoZAxBuim8uDPp+K7bGqiygzSs2vQfr9U5Jhe9/F8sPdtNctfJZEfgmthNTeVFjyNsGIfIt754uGSfACqM7wDLh6fbKx7M+FHlNyOdvYCrbKUOAYXmTikYIpVDvlaaeMO+N+uW8Rhvm1j+JU7CVwhMavLySaPVc6Dt5OxiMMmxw9mVrjW9bBPjS5AkrS5MOA13T5wapoLzH6+gE92U4HzA6ilMcwRaQPSFnK2JU7tzyt2Wy1PH4MjHowXI2WyICG1x510dD3tX1P/1px8ro="
 #        file: lbrynet-${OS}.zip
 #        skip_cleanup: true
 #        overwrite: true
 #        draft: true
 #        on:
 #          tags: true
    - <<: *build
      name: "Mac"
      os: osx
      osx_image: xcode8.3
      language: shell
      env: OS=mac
      before_install:
        - brew uninstall mercurial
        - brew upgrade python || true
        - pip3 install --user --upgrade pip virtualenv
        - /Users/travis/Library/Python/3.7/bin/virtualenv --clear $HOME/venv
        - source $HOME/venv/bin/activate
      before_cache:
        - brew cleanup
    - <<: *build
      name: "Windows"
      os: windows
      language: shell
      env:
        - OS=windows
        - PATH=/c/Python37:/c/Python37/Scripts:/C/Windows/System32/downlevel:$PATH
      before_install:
        - choco install python --version=3.7.4 --x86
        - python -m pip install --upgrade pip
        - pip install pywin32
      script:
        - pyinstaller --additional-hooks-dir=lbry/scripts/. --icon=lbry/icons/lbry256.ico -F -n lbrynet lbry/lbry/extras/cli.py
        - cd dist
        - 7z a -tzip lbrynet-windows.zip lbrynet.exe
        - sha256sum -b lbrynet-windows.zip
        - ./lbrynet.exe --version
    - if: tag IS present
      stage: build
      name: "Wallet Server Docker Image - Tagged Release"
      script:
          - set -e
          - echo "$DOCKER_PASSWORD" | docker login --username "$DOCKER_USERNAME" --password-stdin
          - travis_retry docker build -t lbry/wallet-server:$TRAVIS_TAG -t lbry/wallet-server:latest-release -f docker/Dockerfile.wallet_server .
          - docker push lbry/wallet-server:$TRAVIS_TAG
          - docker push lbry/wallet-server:latest-release
    - if: tag IS blank AND branch = master AND NOT type IN (pull_request)
      stage: build
      name: "Wallet Server Docker Image - Master"
      script:
          - set -e
          - echo "$DOCKER_PASSWORD" | docker login --username "$DOCKER_USERNAME" --password-stdin
          - travis_retry docker build -t lbry/wallet-server:master -f docker/Dockerfile.wallet_server .
          - docker push lbry/wallet-server:master
 cache:
  directories:
    - $HOME/venv
    - $HOME/.cache/pip
    - $HOME/Library/Caches/pip
    - $HOME/Library/Caches/Homebrew
    - $TRAVIS_BUILD_DIR/.tox
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
--- a/INSTALL.md
+++ b/INSTALL.md
@ -9,20 +9,29 @@ Here's a video walkthrough of this setup, which is itself hosted by the LBRY net
 ## Prerequisites
-Running `lbrynet` from source requires Python 3.7 or higher. Get the installer for your OS [here](https://www.python.org/downloads/release/python-370/).
+Running `lbrynet` from source requires Python 3.7. 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.7, you'll need to install some additional libraries depending on your operating system.
 Because of [issue #2769](https://github.com/lbryio/lbry-sdk/issues/2769)
 at the moment the `lbrynet` daemon will only work correctly with Python 3.7.
 If Python 3.8+ is used, the daemon will start but the RPC server
 may not accept messages, returning the following:
 ```
 Could not connect to daemon. Are you sure it's running?
 ```
 ### macOS
 macOS users will need to install [xcode command line tools](https://developer.xamarin.com/guides/testcloud/calabash/configuring/osx/install-xcode-command-line-tools/) and [homebrew](http://brew.sh/).
 These environment variables also need to be set:
-1. PYTHONUNBUFFERED=1
+```
-2. EVENT_NOKQUEUE=1
+PYTHONUNBUFFERED=1
 EVENT_NOKQUEUE=1
 ```
 Remaining dependencies can then be installed by running:
 ```
 brew install python protobuf
 ```
@ -31,14 +40,17 @@ Assistance installing Python3: https://docs.python-guide.org/starting/install3/o
 ### Linux
-On Ubuntu (16.04 minimum, we recommend 18.04), install the following:
+On Ubuntu (we recommend 18.04 or 20.04), install the following:
 ```
 sudo add-apt-repository ppa:deadsnakes/ppa
 sudo apt-get update
 sudo apt-get install build-essential python3.7 python3.7-dev git python3.7-venv libssl-dev python-protobuf
 ```
 The [deadsnakes PPA](https://launchpad.net/~deadsnakes/+archive/ubuntu/ppa) provides Python 3.7
 for those Ubuntu distributions that no longer have it in their
 official repositories.
 On Raspbian, you will also need to install `python-pyparsing`.
 If you're running another Linux distro, install the equivalent of the above packages for your system.
@ -47,65 +59,119 @@ If you're running another Linux distro, install the equivalent of the above pack
 ### Linux/Mac
-To install on Linux/Mac:
+Clone the repository:
 ```bash
 git clone https://github.com/lbryio/lbry-sdk.git
 cd lbry-sdk
 ```
- ```
+Create a Python virtual environment for lbry-sdk:
- Clone the repository:
+```bash
- $ git clone https://github.com/lbryio/lbry-sdk.git
+python3.7 -m venv lbry-venv
- $ cd lbry-sdk
+```
- Create a Python virtual environment for lbry-sdk:
+Activate virtual environment:
- $ python3.7 -m venv lbry-venv
+```bash
 source lbry-venv/bin/activate
 ```
- Activating lbry-sdk virtual environment:
+Make sure you're on Python 3.7+ as default in the virtual environment:
- $ source lbry-venv/bin/activate
+```bash
 python --version
 ```
- Make sure you're on Python 3.7+ (as the default Python in virtual environment):
+Install packages:
- $ python --version
+```bash
 make install
 ```
- Install packages:
+If you are on Linux and using PyCharm, generates initial configs:
- $ make install
+```bash
 make idea
 ```
- If you are on Linux and using PyCharm, generates initial configs:
+To verify your installation, `which lbrynet` should return a path inside
- $ make idea
+of the `lbry-venv` folder.
- ```
+```bash
 (lbry-venv) $ which lbrynet
 /opt/lbry-sdk/lbry-venv/bin/lbrynet
 ```
-To verify your installation, `which lbrynet` should return a path inside of the `lbry-venv` folder created by the `python3.7 -m venv lbry-venv` command.
+To exit the virtual environment simply use the command `deactivate`.
 ### Windows
-To install on Windows:
+Clone the repository:
 ```bash
 git clone https://github.com/lbryio/lbry-sdk.git
 cd lbry-sdk
 ```
- ```
+Create a Python virtual environment for lbry-sdk:
- Clone the repository:
+```bash
- > git clone https://github.com/lbryio/lbry-sdk.git
+python -m venv lbry-venv
- > cd lbry-sdk
+```
- Create a Python virtual environment for lbry-sdk:
+Activate virtual environment:
- > python -m venv lbry-venv
+```bash
 lbry-venv\Scripts\activate
 ```
- Activating lbry-sdk virtual environment:
+Install packages:
- > lbry-venv\Scripts\activate
+```bash
-
+pip install -e .
- Install packages:
+```
 > cd torba
 > pip install -e .
 > cd ../lbry
 > pip install -e .
 ```
 ## Run the tests
 ### Elasticsearch
-To run the unit tests from the repo directory:
+For running integration tests, Elasticsearch is required to be available at localhost:9200/
- ```
+The easiest way to start it is using docker with:
- python -m unittest discover -s lbry tests.unit
+```bash
- ```
+make elastic-docker
 ```
 Alternative installation methods are available [at Elasticsearch website](https://www.elastic.co/guide/en/elasticsearch/reference/current/install-elasticsearch.html).
 To run the unit and integration tests from the repo directory:
 ```
 python -m unittest discover tests.unit
 python -m unittest discover tests.integration
 ```
 ## Usage
 To start the API server:
-    `lbrynet start`
+```
 lbrynet start
 ```
 Whenever the code inside [lbry-sdk/lbry](./lbry)
 is modified we should run `make install` to recompile the `lbrynet`
 executable with the newest code.
 ## Development
 When developing, remember to enter the environment,
 and if you wish start the server interactively.
 ```bash
 $ source lbry-venv/bin/activate
 (lbry-venv) $ python lbry/extras/cli.py start
 ```
 Parameters can be passed in the same way.
 ```bash
 (lbry-venv) $ python lbry/extras/cli.py wallet balance
 ```
 If a Python debugger (`pdb` or `ipdb`) is installed we can also start it
 in this way, set up break points, and step through the code.
 ```bash
 (lbry-venv) $ pip install ipdb
 (lbry-venv) $ ipdb lbry/extras/cli.py
 ```
 Happy hacking!
--- a/2
+++ b/2
@ -1,6 +1,6 @@
 The MIT License (MIT)
-Copyright (c) 2015-2019 LBRY Inc
+Copyright (c) 2015-2022 LBRY Inc
 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,
--- a/torba/MANIFEST.in
+++ b/torba/MANIFEST.in
@ -1,4 +1,4 @@
 include README.md
 include CHANGELOG.md
 include LICENSE
-recursive-include torba *.txt *.py
+recursive-include lbry *.txt *.py
--- a/36
+++ b/36
@ -1,26 +1,26 @@
-.PHONY: install tools lint test idea
+.PHONY: install tools lint test test-unit test-unit-coverage test-integration idea
 install:
-	CFLAGS="-DSQLITE_MAX_VARIABLE_NUMBER=2500000" pip install -U https://github.com/rogerbinns/apsw/releases/download/3.30.1-r1/apsw-3.30.1-r1.zip \
+	pip install -e .
 		--global-option=fetch \
 		--global-option=--version --global-option=3.30.1 --global-option=--all \
 		--global-option=build --global-option=--enable --global-option=fts5
 	cd torba && pip install -e .
 	cd lbry && pip install -e .
 tools:
 	pip install mypy==0.701
 	pip install coverage astroid pylint
 lint:
-	cd lbry && pylint lbry
+	pylint --rcfile=setup.cfg lbry
-	cd torba && pylint --rcfile=setup.cfg torba
+	#mypy --ignore-missing-imports lbry
 	cd torba && mypy --ignore-missing-imports torba
-test:
+test: test-unit test-integration
-	cd lbry && tox
+
-	cd torba && tox
+test-unit:
 	python -m unittest discover tests.unit
 test-unit-coverage:
 	coverage run --source=lbry -m unittest discover -vv tests.unit
 test-integration:
 	tox
 idea:
 	mkdir -p .idea
-	cp -r lbry/scripts/idea/* .idea
+	cp -r scripts/idea/* .idea
 elastic-docker:
 	docker run -d -v lbryhub:/usr/share/elasticsearch/data -p 9200:9200 -p 9300:9300 -e"ES_JAVA_OPTS=-Xms512m -Xmx512m" -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:7.12.1
--- a/README.md
+++ b/README.md
@ -1,15 +1,15 @@
-# <img src="https://raw.githubusercontent.com/lbryio/lbry-sdk/master/lbry/lbry.png" alt="LBRY" width="48" height="36" /> LBRY SDK [![Build Status](https://travis-ci.org/lbryio/lbry-sdk.svg?branch=master)](https://travis-ci.org/lbryio/lbry-sdk) 
+# <img src="https://raw.githubusercontent.com/lbryio/lbry-sdk/master/lbry.png" alt="LBRY" width="48" height="36" /> LBRY SDK [![build](https://github.com/lbryio/lbry-sdk/actions/workflows/main.yml/badge.svg)](https://github.com/lbryio/lbry-sdk/actions/workflows/main.yml) [![coverage](https://coveralls.io/repos/github/lbryio/lbry-sdk/badge.svg)](https://coveralls.io/github/lbryio/lbry-sdk)
 LBRY is a decentralized peer-to-peer protocol for publishing and accessing digital content. 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.
 LBRY SDK for Python is currently the most fully featured implementation of the LBRY Network protocols and includes many useful components and tools for building decentralized applications. Primary features and components include:
- * Built on Python 3.7+ and `asyncio`.
+ * Built on Python 3.7 and `asyncio`.
- * Kademlia DHT (Distributed Hash Table) implementation for finding peers to download from and announcing to peers what we have to host ([lbry.dht](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/dht)).
+ * Kademlia DHT (Distributed Hash Table) implementation for finding peers to download from and announcing to peers what we have to host ([lbry.dht](https://github.com/lbryio/lbry-sdk/tree/master/lbry/dht)).
- * Blob exchange protocol for transferring encrypted blobs of content and negotiating payments ([lbry.blob_exchange](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/blob_exchange)).
+ * Blob exchange protocol for transferring encrypted blobs of content and negotiating payments ([lbry.blob_exchange](https://github.com/lbryio/lbry-sdk/tree/master/lbry/blob_exchange)).
- * Protobuf schema for encoding and decoding metadata stored on the blockchain ([lbry.schema](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/schema)).
+ * Protobuf schema for encoding and decoding metadata stored on the blockchain ([lbry.schema](https://github.com/lbryio/lbry-sdk/tree/master/lbry/schema)).
- * Wallet implementation for the LBRY blockchain ([lbry.wallet](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/wallet)).
+ * Wallet implementation for the LBRY blockchain ([lbry.wallet](https://github.com/lbryio/lbry-sdk/tree/master/lbry/wallet)).
- * Daemon with a JSON-RPC API to ease building end user applications in any language and for automating various tasks ([lbry.extras.daemon](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/extras/daemon)). 
+ * Daemon with a JSON-RPC API to ease building end user applications in any language and for automating various tasks ([lbry.extras.daemon](https://github.com/lbryio/lbry-sdk/tree/master/lbry/extras/daemon)). 
 ## Installation
@ -41,7 +41,7 @@ This project is MIT licensed. For the full license, see [LICENSE](LICENSE).
 ## Security
-We take security seriously. Please contact security@lbry.com regarding any security issues. [Our GPG key is here](https://lbry.com/faq/gpg-key) if you need it.
+We take security seriously. Please contact security@lbry.com regarding any security issues. [Our PGP key is here](https://lbry.com/faq/pgp-key) if you need it.
 ## Contact
@ -53,4 +53,4 @@ 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-sdk/blob/master/lbry/example_daemon_settings.yml).
+Settings can be configured using a daemon-settings.yml file. An example can be found [here](https://github.com/lbryio/lbry-sdk/blob/master/example_daemon_settings.yml).
--- a/SECURITY.md
+++ b/SECURITY.md
@ -0,0 +1,9 @@
 # Security Policy
 ## Supported Versions
 While we are not at v1.0 yet, only the latest release will be supported.
 ## Reporting a Vulnerability
 See https://lbry.com/faq/security
--- a/docker/Dockerfile.dht_node
+++ b/docker/Dockerfile.dht_node
@ -0,0 +1,43 @@
 FROM debian:10-slim
 ARG user=lbry
 ARG projects_dir=/home/$user
 ARG db_dir=/database
 ARG DOCKER_TAG
 ARG DOCKER_COMMIT=docker
 ENV DOCKER_TAG=$DOCKER_TAG DOCKER_COMMIT=$DOCKER_COMMIT
 RUN apt-get update && \
    apt-get -y --no-install-recommends install \
      wget \
      automake libtool \
      tar unzip \
      build-essential \
      pkg-config \
      libleveldb-dev \
      python3.7 \
      python3-dev \
      python3-pip \
      python3-wheel \
      python3-setuptools && \
    update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 1 && \
    rm -rf /var/lib/apt/lists/*
 RUN groupadd -g 999 $user && useradd -m -u 999 -g $user $user
 COPY . $projects_dir
 RUN chown -R $user:$user $projects_dir
 RUN mkdir -p $db_dir
 RUN chown -R $user:$user $db_dir
 USER $user
 WORKDIR $projects_dir
 RUN python3 -m pip install -U setuptools pip
 RUN make install
 RUN python3 docker/set_build.py
 RUN rm ~/.cache -rf
 VOLUME $db_dir
 ENTRYPOINT ["python3", "scripts/dht_node.py"]
--- a/docker/Dockerfile.wallet_server
+++ b/docker/Dockerfile.wallet_server
@ -1,17 +1,26 @@
-FROM ubuntu:19.10
+FROM debian:10-slim
 ARG user=lbry
 ARG db_dir=/database
 ARG projects_dir=/home/$user
 ARG DOCKER_TAG
 ARG DOCKER_COMMIT=docker
 ENV DOCKER_TAG=$DOCKER_TAG DOCKER_COMMIT=$DOCKER_COMMIT
 RUN apt-get update && \
    apt-get -y --no-install-recommends install \
      wget \
      tar unzip \
      build-essential \
-      python3 \
+      automake libtool \
      pkg-config \
      libleveldb-dev \
      python3.7 \
      python3-dev \
      python3-pip \
      python3-wheel \
      python3-cffi \
      python3-setuptools && \
    update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 1 && \
    rm -rf /var/lib/apt/lists/*
@ -28,6 +37,7 @@ WORKDIR $projects_dir
 RUN pip install uvloop
 RUN make install
 RUN python3 docker/set_build.py
 RUN rm ~/.cache -rf
 # entry point
@ -39,7 +49,6 @@ ENV TCP_PORT=$tcp_port
 ENV HOST=$host
 ENV DAEMON_URL=$daemon_url
 ENV DB_DIRECTORY=$db_dir
 ENV BANDWIDTH_LIMIT=1000000000000000000000000000000000000000000
 ENV MAX_SESSIONS=1000000000
 ENV MAX_SEND=1000000000000000000
 ENV EVENT_LOOP_POLICY=uvloop
--- a/docker/Dockerfile.web
+++ b/docker/Dockerfile.web
@ -0,0 +1,45 @@
 FROM debian:10-slim
 ARG user=lbry
 ARG downloads_dir=/database
 ARG projects_dir=/home/$user
 ARG DOCKER_TAG
 ARG DOCKER_COMMIT=docker
 ENV DOCKER_TAG=$DOCKER_TAG DOCKER_COMMIT=$DOCKER_COMMIT
 RUN apt-get update && \
    apt-get -y --no-install-recommends install \
      wget \
      automake libtool \
      tar unzip \
      build-essential \
      pkg-config \
      libleveldb-dev \
      python3.7 \
      python3-dev \
      python3-pip \
      python3-wheel \
      python3-setuptools && \
    update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 1 && \
    rm -rf /var/lib/apt/lists/*
 RUN groupadd -g 999 $user && useradd -m -u 999 -g $user $user
 RUN mkdir -p $downloads_dir
 RUN chown -R $user:$user $downloads_dir
 COPY . $projects_dir
 RUN chown -R $user:$user $projects_dir
 USER $user
 WORKDIR $projects_dir
 RUN pip install uvloop
 RUN make install
 RUN python3 docker/set_build.py
 RUN rm ~/.cache -rf
 # entry point
 VOLUME $downloads_dir
 COPY ./docker/webconf.yaml /webconf.yaml
 ENTRYPOINT ["/home/lbry/.local/bin/lbrynet", "start", "--config=/webconf.yaml"]
--- a/docker/README.md
+++ b/docker/README.md
@ -0,0 +1,9 @@
 ### How to run with docker-compose
 1. Edit config file and after that fix permissions with
 ```
 sudo chown -R 999:999 webconf.yaml
 ```
 2. Start SDK with
 ```
 docker-compose up -d
 ```
--- a/docker/docker-compose-wallet-server.yml
+++ b/docker/docker-compose-wallet-server.yml
@ -1,33 +1,49 @@
 version: "3"
 volumes:
  lbrycrd:
  wallet_server:
  es01:
 services:
  lbrycrd:
    image: lbry/lbrycrd:${LBRYCRD_TAG:-latest-release}
    restart: always
    ports: # accessible from host
      - "9246:9246" # rpc port
    expose: # internal to docker network. also this doesn't do anything. its for documentation only.
      - "9245" # node-to-node comms port
    volumes:
      - "lbrycrd:/data/.lbrycrd"
    environment:
      - RUN_MODE=default
      - SNAPSHOT_URL=${LBRYCRD_SNAPSHOT_URL-https://lbry.com/snapshot/blockchain}
      - RPC_ALLOW_IP=0.0.0.0/0
  wallet_server:
    image: lbry/wallet-server:${WALLET_SERVER_TAG:-latest-release}
    depends_on: 
-      - lbrycrd
+      - es01
    image: lbry/wallet-server:${WALLET_SERVER_TAG:-latest-release}
    restart: always
    network_mode: host
    ports:
      - "50001:50001" # rpc port
-      - "50005:50005" # websocket port
+      - "2112:2112"   # uncomment to enable prometheus
    volumes:
      - "wallet_server:/database"
    environment:
-      - SNAPSHOT_URL=${WALLET_SERVER_SNAPSHOT_URL-https://lbry.com/snapshot/wallet}
+      - DAEMON_URL=http://lbry:lbry@127.0.0.1:9245
-      - DAEMON_URL=http://lbry:lbry@lbrycrd:9245
+      - MAX_QUERY_WORKERS=4
      - CACHE_MB=1024
      - CACHE_ALL_TX_HASHES=
      - CACHE_ALL_CLAIM_TXOS=
      - MAX_SEND=1000000000000000000
      - MAX_RECEIVE=1000000000000000000
      - MAX_SESSIONS=100000
      - HOST=0.0.0.0
      - TCP_PORT=50001
      - PROMETHEUS_PORT=2112
      - FILTERING_CHANNEL_IDS=770bd7ecba84fd2f7607fb15aedd2b172c2e153f 95e5db68a3101df19763f3a5182e4b12ba393ee8
      - BLOCKING_CHANNEL_IDS=dd687b357950f6f271999971f43c785e8067c3a9 06871aa438032244202840ec59a469b303257cad b4a2528f436eca1bf3bf3e10ff3f98c57bd6c4c6
  es01:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.11.0
    container_name: es01
    environment:
      - node.name=es01
      - discovery.type=single-node
      - indices.query.bool.max_clause_count=8192
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"  # no more than 32, remember to disable swap
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es01:/usr/share/elasticsearch/data
    ports:
      - 127.0.0.1:9200:9200
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@ -0,0 +1,9 @@
 version: '3'
 services:
    websdk:
        image: vshyba/websdk
        ports:
            - '5279:5279'
            - '5280:5280'
        volumes:
            - ./webconf.yaml:/webconf.yaml
--- a/docker/hooks/build
+++ b/docker/hooks/build
@ -0,0 +1,7 @@
 #!/bin/bash
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 cd "$DIR/../.." ## make sure we're in the right place. Docker Hub screws this up sometimes
 echo "docker build dir: $(pwd)"
 docker build --build-arg DOCKER_TAG=$DOCKER_TAG --build-arg DOCKER_COMMIT=$SOURCE_COMMIT -f $DOCKERFILE_PATH -t $IMAGE_NAME .
--- a/docker/set_build.py
+++ b/docker/set_build.py
@ -1,38 +1,43 @@
 """Set the build version to be 'qa', 'rc', 'release'"""
 import sys
 import os
 import re
 import logging
 import lbry.build_info as build_info_mod
 log = logging.getLogger()
 log.addHandler(logging.StreamHandler())
 log.setLevel(logging.DEBUG)
-def get_build_type(ci_tag=None):
+def _check_and_set(d: dict, key: str, value: str):
-    if not ci_tag:
+    try:
-        return "qa"
+        d[key]
-    log.debug("getting build type for tag: \"%s\"", ci_tag)
+    except KeyError:
-    if re.match(r'v\d+\.\d+\.\d+rc\d+$', ci_tag):
+        raise Exception(f"{key} var does not exist in {build_info_mod.__file__}")
-        return 'rc'
+    d[key] = value
    elif re.match(r'v\d+\.\d+\.\d+$', ci_tag):
        return 'release'
    return 'qa'
 def main():
-    root_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    build_info = {item: build_info_mod.__dict__[item] for item in dir(build_info_mod) if not item.startswith("__")}
-    build_type_path = os.path.join(root_dir, 'lbry', 'lbry', 'build_type.py')
+
-    log.debug("configuring build type file: %s", build_type_path)
+    commit_hash = os.getenv('DOCKER_COMMIT', os.getenv('GITHUB_SHA'))
    commit_hash = os.getenv('CI_COMMIT_SHA', os.getenv('TRAVIS_COMMIT'))
    if commit_hash is None:
        raise ValueError("Commit hash not found in env vars")
-    commit_hash = commit_hash[:6]
+    _check_and_set(build_info, "COMMIT_HASH", commit_hash[:6])
-    build_type = get_build_type(os.getenv('CI_COMMIT_TAG', os.getenv('TRAVIS_TAG')))
+
-    log.debug("setting build type=%s, build commit=%s", build_type, commit_hash)
+    docker_tag = os.getenv('DOCKER_TAG')
-    with open(build_type_path, 'w') as f:
+    if docker_tag:
-        f.write(f"BUILD = \"{build_type}\"\nBUILD_COMMIT = \"{commit_hash}\"\n")
+        _check_and_set(build_info, "DOCKER_TAG", docker_tag)
        _check_and_set(build_info, "BUILD", "docker")
    else:
        if re.match(r'refs/tags/v\d+\.\d+\.\d+$', str(os.getenv('GITHUB_REF'))):
            _check_and_set(build_info, "BUILD", "release")
        else:
            _check_and_set(build_info, "BUILD", "qa")
    log.debug("build info: %s", ", ".join([f"{k}={v}" for k, v in build_info.items()]))
    with open(build_info_mod.__file__, 'w') as f:
        f.write("\n".join([f"{k} = \"{v}\"" for k, v in build_info.items()]) + "\n")
 if __name__ == '__main__':
--- a/docker/wallet_server_entrypoint.sh
+++ b/docker/wallet_server_entrypoint.sh
@ -2,14 +2,24 @@
 # entrypoint for wallet server Docker image
 set -euo pipefail
 SNAPSHOT_URL="${SNAPSHOT_URL:-}" #off by default. latest snapshot at https://lbry.com/snapshot/wallet
-if [[ -n "$SNAPSHOT_URL" ]] && [[ ! -f /database/claims.db ]]; then
+if [[ -n "$SNAPSHOT_URL" ]] && [[ ! -f /database/lbry-leveldb ]]; then
  files="$(ls)"
  echo "Downloading wallet snapshot from $SNAPSHOT_URL"
-  wget --no-verbose -O wallet_snapshot.tar.bz2 "$SNAPSHOT_URL"
+  wget --no-verbose --trust-server-names --content-disposition "$SNAPSHOT_URL"
  echo "Extracting snapshot..."
-  tar xvjf wallet_snapshot.tar.bz2 --directory /database
+  filename="$(grep -vf <(echo "$files") <(ls))" # finds the file that was not there before
-  rm wallet_snapshot.tar.bz2
+  case "$filename" in
    *.tgz|*.tar.gz|*.tar.bz2 )  tar xvf "$filename" --directory /database ;;
    *.zip ) unzip "$filename" -d /database ;;
    * ) echo "Don't know how to extract ${filename}. SNAPSHOT COULD NOT BE LOADED" && exit 1 ;;
  esac
  rm "$filename"
 fi
-/home/lbry/.local/bin/torba-server "$@"
+/home/lbry/.local/bin/lbry-hub-elastic-sync
 echo 'starting server'
 /home/lbry/.local/bin/lbry-hub "$@"
--- a/docker/webconf.yaml
+++ b/docker/webconf.yaml
@ -0,0 +1,9 @@
 allowed_origin: "*"
 max_key_fee: "0.0 USD"
 save_files: false
 save_blobs: false
 streaming_server: "0.0.0.0:5280"
 api: "0.0.0.0:5279"
 data_dir: /tmp
 download_dir: /tmp
 wallet_dir: /tmp
--- a/docs/api.json
+++ b/docs/api.json
--- a/lbry/example_daemon_settings.yml
+++ b/lbry/example_daemon_settings.yml
--- a/lbry/icons/128x128.png
+++ b/lbry/icons/128x128.png
--- a/lbry/icons/256x256.png
+++ b/lbry/icons/256x256.png
--- a/lbry/icons/32x32.png
+++ b/lbry/icons/32x32.png
--- a/lbry/icons/48x48.png
+++ b/lbry/icons/48x48.png
--- a/lbry/icons/96x96.png
+++ b/lbry/icons/96x96.png
--- a/lbry/icons/lbry128.ico
+++ b/lbry/icons/lbry128.ico
--- a/lbry/icons/lbry16.ico
+++ b/lbry/icons/lbry16.ico
--- a/lbry/icons/lbry256.ico
+++ b/lbry/icons/lbry256.ico
--- a/lbry/icons/lbry32.ico
+++ b/lbry/icons/lbry32.ico
--- a/lbry/icons/lbry48.ico
+++ b/lbry/icons/lbry48.ico
--- a/lbry/icons/lbry96.ico
+++ b/lbry/icons/lbry96.ico
--- a/lbry/lbry.png
+++ b/lbry/lbry.png
--- a/lbry/.gitattributes
+++ b/lbry/.gitattributes
@ -1 +0,0 @@
 /CHANGELOG.md merge=union
--- a/lbry/.gitignore
+++ b/lbry/.gitignore
@ -1,14 +0,0 @@
 .DS_Store
 /build
 /dist
 /.tox
 /.idea
 /.coverage
 /lbry-venv
 lbry.egg-info
 __pycache__
 _trial_temp/
 /tests/integration/files
 /tests/.coverage.*
--- a/lbry/.pylintrc
+++ b/lbry/.pylintrc
@ -1,441 +0,0 @@
 [MASTER]
 # Specify a configuration file.
 #rcfile=
 # Python code to execute, usually for sys.path manipulation such as
 # pygtk.require().
 #init-hook=
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
 ignore=CVS,schema
 # Add files or directories matching the regex patterns to the
 # blacklist. The regex matches against base names, not paths.
 # `\.#.*` - add emacs tmp files to the blacklist
 ignore-patterns=\.#.*
 # Pickle collected data for later comparisons.
 persistent=yes
 # List of plugins (as comma separated values of python modules names) to load,
 # usually to register additional checkers.
 load-plugins=
 # Use multiple processes to speed up Pylint.
 jobs=4
 # Allow loading of arbitrary C extensions. Extensions are imported into the
 # active Python interpreter and may run arbitrary code.
 unsafe-load-any-extension=no
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code
 extension-pkg-whitelist=apsw
 # Allow optimization of some AST trees. This will activate a peephole AST
 # optimizer, which will apply various small optimizations. For instance, it can
 # be used to obtain the result of joining multiple strings with the addition
 # operator. Joining a lot of strings can lead to a maximum recursion error in
 # Pylint and this flag can prevent that. It has one side effect, the resulting
 # AST will be different than the one from reality.
 optimize-ast=no
 [MESSAGES CONTROL]
 # Only show warnings with the listed confidence levels. Leave empty to show
 # all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
 confidence=
 # Enable the message, report, category or checker with the given id(s). You can
 # either give multiple identifier separated by comma (,) or put this option
 # multiple time (only on the command line, not in the configuration file where
 # it should appear only once). See also the "--disable" option for examples.
 #enable=
 # Disable the message, report, category or checker with the given id(s). You
 # can either give multiple identifiers separated by comma (,) or put this
 # option multiple times (only on the command line, not in the configuration
 # file where it should appear only once).You can also use "--disable=all" to
 # disable everything first and then re-enable specific checks. For example, if
 # you want to run only the similarities checker, you can use "--disable=all
 # --enable=similarities". If you want to run only the classes checker, but have
 # no Warning level messages displayed, use"--disable=all --enable=classes
 # --disable=W"
 disable=
  anomalous-backslash-in-string,
  arguments-differ,
  attribute-defined-outside-init,
  bad-continuation,
  bare-except,
  broad-except,
  cell-var-from-loop,
  consider-iterating-dictionary,
  dangerous-default-value,
  duplicate-code,
  fixme,
  invalid-name,
  len-as-condition,
  locally-disabled,
  logging-not-lazy,
  missing-docstring,
  no-else-return,
  no-init,
  no-member,
  no-self-use,
  protected-access,
  redefined-builtin,
  redefined-outer-name,
  redefined-variable-type,
  relative-import,
  signature-differs,
  super-init-not-called,
  too-few-public-methods,
  too-many-arguments,
  too-many-branches,
  too-many-instance-attributes,
  too-many-lines,
  too-many-locals,
  too-many-nested-blocks,
  too-many-public-methods,
  too-many-return-statements,
  too-many-statements,
  trailing-newlines,
  undefined-loop-variable,
  ungrouped-imports,
  unnecessary-lambda,
  unused-argument,
  unused-variable,
  wrong-import-order,
  wrong-import-position,
  deprecated-lambda,
  simplifiable-if-statement,
  unidiomatic-typecheck,
  inconsistent-return-statements,
  keyword-arg-before-vararg,
  assignment-from-no-return,
  useless-return,
  assignment-from-none,
  stop-iteration-return
 [REPORTS]
 # Set the output format. Available formats are text, parseable, colorized, msvs
 # (visual studio) and html. You can also give a reporter class, eg
 # mypackage.mymodule.MyReporterClass.
 output-format=text
 # Put messages in a separate file for each module / package specified on the
 # command line instead of printing them on stdout. Reports (if any) will be
 # written in a file name "pylint_global.[txt|html]".
 files-output=no
 # Tells whether to display a full report or only the messages
 reports=no
 # Python expression which should return a note less than 10 (10 is the highest
 # note). You have access to the variables errors warning, statement which
 # respectively contain the number of errors / warnings messages and the total
 # number of statements analyzed. This is used by the global evaluation report
 # (RP0004).
 evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
 # Template used to display messages. This is a python new-style format string
 # used to format the message information. See doc for all details
 #msg-template=
 [VARIABLES]
 # Tells whether we should check for unused import in __init__ files.
 init-import=no
 # A regular expression matching the name of dummy variables (i.e. expectedly
 # not used).
 dummy-variables-rgx=_$|dummy
 # List of additional names supposed to be defined in builtins. Remember that
 # you should avoid to define new builtins when possible.
 additional-builtins=
 # List of strings which can identify a callback function by name. A callback
 # name must start or end with one of those strings.
 callbacks=cb_,_cb
 [LOGGING]
 # Logging modules to check that the string format arguments are in logging
 # function parameter format
 logging-modules=logging
 [BASIC]
 # List of builtins function names that should not be used, separated by a comma
 bad-functions=map,filter,input
 # Good variable names which should always be accepted, separated by a comma
 # allow `d` as its used frequently for deferred callback chains
 good-names=i,j,k,ex,Run,_,d
 # Bad variable names which should always be refused, separated by a comma
 bad-names=foo,bar,baz,toto,tutu,tata
 # Colon-delimited sets of names that determine each other's naming style when
 # the name regexes allow several styles.
 name-group=
 # Include a hint for the correct naming format with invalid-name
 include-naming-hint=no
 # Regular expression matching correct function names
 function-rgx=[a-z_][a-z0-9_]{2,30}$
 # Naming hint for function names
 function-name-hint=[a-z_][a-z0-9_]{2,30}$
 # Regular expression matching correct variable names
 variable-rgx=[a-z_][a-z0-9_]{2,30}$
 # Naming hint for variable names
 variable-name-hint=[a-z_][a-z0-9_]{2,30}$
 # Regular expression matching correct constant names
 const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
 # Naming hint for constant names
 const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
 # Regular expression matching correct attribute names
 attr-rgx=[a-z_][a-z0-9_]{2,30}$
 # Naming hint for attribute names
 attr-name-hint=[a-z_][a-z0-9_]{2,30}$
 # Regular expression matching correct argument names
 argument-rgx=[a-z_][a-z0-9_]{2,30}$
 # Naming hint for argument names
 argument-name-hint=[a-z_][a-z0-9_]{2,30}$
 # Regular expression matching correct class attribute names
 class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
 # Naming hint for class attribute names
 class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
 # Regular expression matching correct inline iteration names
 inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
 # Naming hint for inline iteration names
 inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
 # Regular expression matching correct class names
 class-rgx=[A-Z_][a-zA-Z0-9]+$
 # Naming hint for class names
 class-name-hint=[A-Z_][a-zA-Z0-9]+$
 # Regular expression matching correct module names
 module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
 # Naming hint for module names
 module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
 # Regular expression matching correct method names
 method-rgx=[a-z_][a-z0-9_]{2,30}$
 # Naming hint for method names
 method-name-hint=[a-z_][a-z0-9_]{2,30}$
 # Regular expression which should only match function or class names that do
 # not require a docstring.
 no-docstring-rgx=^_
 # Minimum line length for functions/classes that require docstrings, shorter
 # ones are exempt.
 docstring-min-length=-1
 [ELIF]
 # Maximum number of nested blocks for function / method body
 max-nested-blocks=5
 [SPELLING]
 # Spelling dictionary name. Available dictionaries: none. To make it working
 # install python-enchant package.
 spelling-dict=
 # List of comma separated words that should not be checked.
 spelling-ignore-words=
 # A path to a file that contains private dictionary; one word per line.
 spelling-private-dict-file=
 # Tells whether to store unknown words to indicated private dictionary in
 # --spelling-private-dict-file option instead of raising a message.
 spelling-store-unknown-words=no
 [FORMAT]
 # Maximum number of characters on a single line.
 max-line-length=120
 # Regexp for a line that is allowed to be longer than the limit.
 ignore-long-lines=^\s*(# )?<?https?://\S+>?$
 # Allow the body of an if to be on the same line as the test if there is no
 # else.
 single-line-if-stmt=no
 # List of optional constructs for which whitespace checking is disabled. `dict-
 # separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
 # `trailing-comma` allows a space between comma and closing bracket: (a, ).
 # `empty-line` allows space-only lines.
 no-space-check=trailing-comma,dict-separator
 # Maximum number of lines in a module
 max-module-lines=1000
 # String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
 # tab).
 indent-string='    '
 # Number of spaces of indent required inside a hanging  or continued line.
 indent-after-paren=4
 # Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
 expected-line-ending-format=
 [MISCELLANEOUS]
 # List of note tags to take in consideration, separated by a comma.
 notes=FIXME,XXX,TODO
 [SIMILARITIES]
 # Minimum lines number of a similarity.
 min-similarity-lines=4
 # Ignore comments when computing similarities.
 ignore-comments=yes
 # Ignore docstrings when computing similarities.
 ignore-docstrings=yes
 # Ignore imports when computing similarities.
 ignore-imports=no
 [TYPECHECK]
 # Tells whether missing members accessed in mixin class should be ignored. A
 # mixin class is detected if its name ends with "mixin" (case insensitive).
 ignore-mixin-members=yes
 # List of module names for which member attributes should not be checked
 # (useful for modules/projects where namespaces are manipulated during runtime
 # and thus existing member attributes cannot be deduced by static analysis. It
 # supports qualified module names, as well as Unix pattern matching.
 ignored-modules=leveldb,distutils
 # Ignoring distutils because: https://github.com/PyCQA/pylint/issues/73
 # List of classes names for which member attributes should not be checked
 # (useful for classes with attributes dynamically set). This supports can work
 # with qualified names.
 # ignored-classes=
 # List of members which are set dynamically and missed by pylint inference
 # system, and so shouldn't trigger E1101 when accessed. Python regular
 # expressions are accepted.
 generated-members=lbrynet.lbrynet_daemon.LBRYDaemon.Parameters
 [IMPORTS]
 # Deprecated modules which should not be used, separated by a comma
 deprecated-modules=regsub,TERMIOS,Bastion,rexec
 # Create a graph of every (i.e. internal and external) dependencies in the
 # given file (report RP0402 must not be disabled)
 import-graph=
 # Create a graph of external dependencies in the given file (report RP0402 must
 # not be disabled)
 ext-import-graph=
 # Create a graph of internal dependencies in the given file (report RP0402 must
 # not be disabled)
 int-import-graph=
 [DESIGN]
 # Maximum number of arguments for function / method
 max-args=10
 # Argument names that match this expression will be ignored. Default to name
 # with leading underscore
 ignored-argument-names=_.*
 # Maximum number of locals for function / method body
 max-locals=15
 # Maximum number of return / yield for function / method body
 max-returns=6
 # Maximum number of branch for function / method body
 max-branches=12
 # Maximum number of statements in function / method body
 max-statements=50
 # Maximum number of parents for a class (see R0901).
 max-parents=8
 # Maximum number of attributes for a class (see R0902).
 max-attributes=7
 # Minimum number of public methods for a class (see R0903).
 min-public-methods=2
 # Maximum number of public methods for a class (see R0904).
 max-public-methods=20
 # Maximum number of boolean expressions in a if statement
 max-bool-expr=5
 [CLASSES]
 # List of method names used to declare (i.e. assign) instance attributes.
 defining-attr-methods=__init__,__new__,setUp
 # List of valid names for the first argument in a class method.
 valid-classmethod-first-arg=cls
 # List of valid names for the first argument in a metaclass class method.
 valid-metaclass-classmethod-first-arg=mcs
 # List of member names, which should be excluded from the protected access
 # warning.
 exclude-protected=_asdict,_fields,_replace,_source,_make
 [EXCEPTIONS]
 # Exceptions that will emit a warning when being caught. Defaults to
 # "Exception"
 overgeneral-exceptions=Exception
--- a/lbry/README.md
+++ b/lbry/README.md
@ -1,56 +0,0 @@
 # <img src="https://raw.githubusercontent.com/lbryio/lbry-sdk/master/lbry/lbry.png" alt="LBRY" width="48" height="36" /> LBRY SDK [![Build Status](https://travis-ci.org/lbryio/lbry-sdk.svg?branch=master)](https://travis-ci.org/lbryio/lbry-sdk)
 LBRY is a decentralized peer-to-peer protocol for publishing and accessing digital content. 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.
 LBRY SDK for Python is currently the most full featured implementation of the LBRY Network protocols and includes many useful components and tools for building decentralized applications. Primary features and components:
 * Built on Python 3.7+ and `asyncio`.
 * Kademlia DHT (Distributed Hash Table) implementation for finding peers to download from and announcing to peers what we have to host ([lbry.dht](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/dht)).
 * Blob exchange protocol for transferring encrypted blobs of content and negotiating payments ([lbry.blob_exchange](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/blob_exchange)).
 * Protobuf schema for encoding and decoding metadata stored on the blockchain ([lbry.schema](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/schema)).
 * Wallet implementation for the LBRY blockchain ([lbry.wallet](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/wallet)).
 * Daemon with a JSON-RPC API to ease building end user applications in any language and for automating various tasks ([lbry.extras.daemon](https://github.com/lbryio/lbry-sdk/tree/master/lbry/lbry/extras/daemon)). 
 ## Installation
 Our [releases page](https://github.com/lbryio/lbry-sdk/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
 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](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)
 ## Contributing
 Contributions to this project are welcome, encouraged, and compensated. For more details, please check [this](https://lbry.tech/contribute) link.
 ## License
 This project is MIT licensed. For the full license, see [LICENSE](LICENSE).
 ## Security
 We take security seriously. Please contact security@lbry.com regarding any security issues. [Our GPG key is here](https://lbry.com/faq/gpg-key) if you need it.
 ## Contact
 The primary contact for this project is [@eukreign](mailto:lex@lbry.com).
 ## 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-sdk/blob/master/lbry/example_daemon_settings.yml).
--- a/lbry/init.py
+++ b/lbry/init.py
@ -0,0 +1,2 @@
 __version__ = "0.113.0"
 version = tuple(map(int, __version__.split('.')))  # pylint: disable=invalid-name
--- a/lbry/blob/init.py
+++ b/lbry/blob/init.py
@ -0,0 +1,6 @@
 from lbry.utils import get_lbry_hash_obj
 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
--- a/lbry/lbry/blob/blob_file.py
+++ b/lbry/lbry/blob/blob_file.py
@ -1,5 +1,6 @@
 import os
 import re
 import time
 import asyncio
 import binascii
 import logging
@ -9,18 +10,20 @@ from io import BytesIO
 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 lbry.cryptoutils import backend, get_lbry_hash_obj
+from lbry.utils import get_lbry_hash_obj
 from lbry.error import DownloadCancelledError, InvalidBlobHashError, InvalidDataError
-from lbry.blob import MAX_BLOB_SIZE, blobhash_length
+from lbry.blob import MAX_BLOB_SIZE, BLOBHASH_LENGTH
 from lbry.blob.blob_info import BlobInfo
 from lbry.blob.writer import HashBlobWriter
 log = logging.getLogger(__name__)
-_hexmatch = re.compile("^[a-f,0-9]+$")
+HEXMATCH = re.compile("^[a-f,0-9]+$")
 BACKEND = default_backend()
 def is_valid_blobhash(blobhash: str) -> bool:
@ -31,11 +34,11 @@ def is_valid_blobhash(blobhash: str) -> bool:
    @return: True/False
    """
-    return len(blobhash) == blobhash_length and _hexmatch.match(blobhash)
+    return len(blobhash) == BLOBHASH_LENGTH and HEXMATCH.match(blobhash)
 def encrypt_blob_bytes(key: bytes, iv: bytes, unencrypted: bytes) -> typing.Tuple[bytes, str]:
-    cipher = Cipher(AES(key), modes.CBC(iv), backend=backend)
+    cipher = Cipher(AES(key), modes.CBC(iv), backend=BACKEND)
    padder = PKCS7(AES.block_size).padder()
    encryptor = cipher.encryptor()
    encrypted = encryptor.update(padder.update(unencrypted) + padder.finalize()) + encryptor.finalize()
@ -47,7 +50,7 @@ def encrypt_blob_bytes(key: bytes, iv: bytes, unencrypted: bytes) -> typing.Tupl
 def decrypt_blob_bytes(data: bytes, length: int, key: bytes, iv: bytes) -> bytes:
    if len(data) != length:
        raise ValueError("unexpected length")
-    cipher = Cipher(AES(key), modes.CBC(iv), backend=backend)
+    cipher = Cipher(AES(key), modes.CBC(iv), backend=BACKEND)
    unpadder = PKCS7(AES.block_size).unpadder()
    decryptor = cipher.decryptor()
    return unpadder.update(decryptor.update(data) + decryptor.finalize()) + unpadder.finalize()
@ -68,21 +71,27 @@ class AbstractBlob:
        'writers',
        'verified',
        'writing',
-        'readers'
+        'readers',
        'added_on',
        'is_mine',
    ]
-    def __init__(self, loop: asyncio.AbstractEventLoop, blob_hash: str, length: typing.Optional[int] = None,
+    def __init__(
-                 blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None,
+        self, loop: asyncio.AbstractEventLoop, blob_hash: str, length: typing.Optional[int] = None,
-                 blob_directory: typing.Optional[str] = None):
+        blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None,
        blob_directory: typing.Optional[str] = None, added_on: typing.Optional[int] = None, is_mine: bool = False,
    ):
        self.loop = loop
        self.blob_hash = blob_hash
        self.length = length
        self.blob_completed_callback = blob_completed_callback
        self.blob_directory = blob_directory
        self.writers: typing.Dict[typing.Tuple[typing.Optional[str], typing.Optional[int]], HashBlobWriter] = {}
-        self.verified: asyncio.Event = asyncio.Event(loop=self.loop)
+        self.verified: asyncio.Event = asyncio.Event()
-        self.writing: asyncio.Event = asyncio.Event(loop=self.loop)
+        self.writing: asyncio.Event = asyncio.Event()
        self.readers: typing.List[typing.BinaryIO] = []
        self.added_on = added_on or time.time()
        self.is_mine = is_mine
        if not is_valid_blobhash(blob_hash):
            raise InvalidBlobHashError(blob_hash)
@ -108,7 +117,7 @@ class AbstractBlob:
                if reader in self.readers:
                    self.readers.remove(reader)
-    def _write_blob(self, blob_bytes: bytes):
+    def _write_blob(self, blob_bytes: bytes) -> asyncio.Task:
        raise NotImplementedError()
    def set_length(self, length) -> None:
@ -142,7 +151,7 @@ class AbstractBlob:
    def close(self):
        while self.writers:
-            peer, writer = self.writers.popitem()
+            _, writer = self.writers.popitem()
            if writer and writer.finished and not writer.finished.done() and not self.loop.is_closed():
                writer.finished.cancel()
        while self.readers:
@ -165,7 +174,7 @@ class AbstractBlob:
        with self.reader_context() as handle:
            try:
                return await self.loop.sendfile(writer.transport, handle, count=self.get_length())
-            except (ConnectionResetError, BrokenPipeError, RuntimeError, OSError, AttributeError):
+            except (ConnectionError, BrokenPipeError, RuntimeError, OSError, AttributeError):
                return -1
    def decrypt(self, key: bytes, iv: bytes) -> bytes:
@ -178,35 +187,42 @@ class AbstractBlob:
    @classmethod
    async def create_from_unencrypted(
-            cls, loop: asyncio.AbstractEventLoop, blob_dir: typing.Optional[str], key: bytes, iv: bytes,
+        cls, loop: asyncio.AbstractEventLoop, blob_dir: typing.Optional[str], key: bytes, iv: bytes,
-            unencrypted: bytes, blob_num: int,
+        unencrypted: bytes, blob_num: int, added_on: int, is_mine: bool,
-            blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], None]] = None) -> BlobInfo:
+        blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], None]] = None,
    ) -> BlobInfo:
        """
        Create an encrypted BlobFile from plaintext bytes
        """
        blob_bytes, blob_hash = encrypt_blob_bytes(key, iv, unencrypted)
        length = len(blob_bytes)
-        blob = cls(loop, blob_hash, length, blob_completed_callback, blob_dir)
+        blob = cls(loop, blob_hash, length, blob_completed_callback, blob_dir, added_on, is_mine)
        writer = blob.get_blob_writer()
        writer.write(blob_bytes)
        await blob.verified.wait()
-        return BlobInfo(blob_num, length, binascii.hexlify(iv).decode(), blob_hash)
+        return BlobInfo(blob_num, length, binascii.hexlify(iv).decode(), added_on, blob_hash, is_mine)
    def save_verified_blob(self, verified_bytes: bytes):
        if self.verified.is_set():
            return
-        if self.is_writeable():
+
-            self._write_blob(verified_bytes)
+        def update_events(_):
            self.verified.set()
            self.writing.clear()
        if self.is_writeable():
            self.writing.set()
            task = self._write_blob(verified_bytes)
            task.add_done_callback(update_events)
            if self.blob_completed_callback:
-                self.blob_completed_callback(self)
+                task.add_done_callback(lambda _: self.blob_completed_callback(self))
    def get_blob_writer(self, peer_address: typing.Optional[str] = None,
                        peer_port: typing.Optional[int] = None) -> HashBlobWriter:
        if (peer_address, peer_port) in self.writers and not self.writers[(peer_address, peer_port)].closed():
            raise OSError(f"attempted to download blob twice from {peer_address}:{peer_port}")
-        fut = asyncio.Future(loop=self.loop)
+        fut = asyncio.Future()
        writer = HashBlobWriter(self.blob_hash, self.get_length, fut)
        self.writers[(peer_address, peer_port)] = writer
@ -240,11 +256,13 @@ class BlobBuffer(AbstractBlob):
    """
    An in-memory only blob
    """
-    def __init__(self, loop: asyncio.AbstractEventLoop, blob_hash: str, length: typing.Optional[int] = None,
+    def __init__(
-                 blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None,
+        self, loop: asyncio.AbstractEventLoop, blob_hash: str, length: typing.Optional[int] = None,
-                 blob_directory: typing.Optional[str] = None):
+        blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None,
        blob_directory: typing.Optional[str] = None, added_on: typing.Optional[int] = None, is_mine: bool = False
    ):
        self._verified_bytes: typing.Optional[BytesIO] = None
-        super().__init__(loop, blob_hash, length, blob_completed_callback, blob_directory)
+        super().__init__(loop, blob_hash, length, blob_completed_callback, blob_directory, added_on, is_mine)
    @contextlib.contextmanager
    def _reader_context(self) -> typing.ContextManager[typing.BinaryIO]:
@ -259,9 +277,11 @@ class BlobBuffer(AbstractBlob):
            self.verified.clear()
    def _write_blob(self, blob_bytes: bytes):
-        if self._verified_bytes:
+        async def write():
-            raise OSError("already have bytes for blob")
+            if self._verified_bytes:
-        self._verified_bytes = BytesIO(blob_bytes)
+                raise OSError("already have bytes for blob")
            self._verified_bytes = BytesIO(blob_bytes)
        return self.loop.create_task(write())
    def delete(self):
        if self._verified_bytes:
@ -279,10 +299,12 @@ class BlobFile(AbstractBlob):
    """
    A blob existing on the local file system
    """
-    def __init__(self, loop: asyncio.AbstractEventLoop, blob_hash: str, length: typing.Optional[int] = None,
+    def __init__(
-                 blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None,
+        self, loop: asyncio.AbstractEventLoop, blob_hash: str, length: typing.Optional[int] = None,
-                 blob_directory: typing.Optional[str] = None):
+        blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None,
-        super().__init__(loop, blob_hash, length, blob_completed_callback, blob_directory)
+        blob_directory: typing.Optional[str] = None, added_on: typing.Optional[int] = None, is_mine: bool = False
    ):
        super().__init__(loop, blob_hash, length, blob_completed_callback, blob_directory, added_on, is_mine)
        if not blob_directory or not os.path.isdir(blob_directory):
            raise OSError(f"invalid blob directory '{blob_directory}'")
        self.file_path = os.path.join(self.blob_directory, self.blob_hash)
@ -317,22 +339,28 @@ class BlobFile(AbstractBlob):
            handle.close()
    def _write_blob(self, blob_bytes: bytes):
-        with open(self.file_path, 'wb') as f:
+        def _write_blob():
-            f.write(blob_bytes)
+            with open(self.file_path, 'wb') as f:
                f.write(blob_bytes)
        async def write_blob():
            await self.loop.run_in_executor(None, _write_blob)
        return self.loop.create_task(write_blob())
    def delete(self):
        super().delete()
        if os.path.isfile(self.file_path):
            os.remove(self.file_path)
        return super().delete()
    @classmethod
    async def create_from_unencrypted(
-            cls, loop: asyncio.AbstractEventLoop, blob_dir: typing.Optional[str], key: bytes, iv: bytes,
+        cls, loop: asyncio.AbstractEventLoop, blob_dir: typing.Optional[str], key: bytes, iv: bytes,
-            unencrypted: bytes, blob_num: int,
+        unencrypted: bytes, blob_num: int, added_on: float, is_mine: bool,
-            blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'],
+        blob_completed_callback: typing.Optional[typing.Callable[['AbstractBlob'], asyncio.Task]] = None
-                                                                     asyncio.Task]] = None) -> BlobInfo:
+    ) -> BlobInfo:
        if not blob_dir or not os.path.isdir(blob_dir):
            raise OSError(f"cannot create blob in directory: '{blob_dir}'")
        return await super().create_from_unencrypted(
-            loop, blob_dir, key, iv, unencrypted, blob_num, blob_completed_callback
+            loop, blob_dir, key, iv, unencrypted, blob_num, added_on, is_mine, blob_completed_callback
        )
--- a/lbry/lbry/blob/blob_info.py
+++ b/lbry/lbry/blob/blob_info.py
@ -7,13 +7,19 @@ class BlobInfo:
        'blob_num',
        'length',
        'iv',
        'added_on',
        'is_mine'
    ]
-    def __init__(self, blob_num: int, length: int, iv: str, blob_hash: typing.Optional[str] = None):
+    def __init__(
            self, blob_num: int, length: int, iv: str, added_on,
             blob_hash: typing.Optional[str] = None, is_mine=False):
        self.blob_hash = blob_hash
        self.blob_num = blob_num
        self.length = length
        self.iv = iv
        self.added_on = added_on
        self.is_mine = is_mine
    def as_dict(self) -> typing.Dict:
        d = {
--- a/lbry/lbry/blob/blob_manager.py
+++ b/lbry/lbry/blob/blob_manager.py
@ -2,7 +2,7 @@ import os
 import typing
 import asyncio
 import logging
-from lbry.utils import LRUCache
+from lbry.utils import LRUCacheWithMetrics
 from lbry.blob.blob_file import is_valid_blobhash, BlobFile, BlobBuffer, AbstractBlob
 from lbry.stream.descriptor import StreamDescriptor
 from lbry.connection_manager import ConnectionManager
@ -32,34 +32,34 @@ class BlobManager:
            else self._node_data_store.completed_blobs
        self.blobs: typing.Dict[str, AbstractBlob] = {}
        self.config = config
-        self.decrypted_blob_lru_cache = None if not self.config.blob_lru_cache_size else LRUCache(
+        self.decrypted_blob_lru_cache = None if not self.config.blob_lru_cache_size else LRUCacheWithMetrics(
            self.config.blob_lru_cache_size)
        self.connection_manager = ConnectionManager(loop)
-    def _get_blob(self, blob_hash: str, length: typing.Optional[int] = None):
+    def _get_blob(self, blob_hash: str, length: typing.Optional[int] = None, is_mine: bool = False):
        if self.config.save_blobs or (
                is_valid_blobhash(blob_hash) and os.path.isfile(os.path.join(self.blob_dir, blob_hash))):
            return BlobFile(
-                self.loop, blob_hash, length, self.blob_completed, self.blob_dir
+                self.loop, blob_hash, length, self.blob_completed, self.blob_dir, is_mine=is_mine
            )
        return BlobBuffer(
-            self.loop, blob_hash, length, self.blob_completed, self.blob_dir
+            self.loop, blob_hash, length, self.blob_completed, self.blob_dir, is_mine=is_mine
        )
-    def get_blob(self, blob_hash, length: typing.Optional[int] = None):
+    def get_blob(self, blob_hash, length: typing.Optional[int] = None, is_mine: bool = False):
        if blob_hash in self.blobs:
            if self.config.save_blobs and isinstance(self.blobs[blob_hash], BlobBuffer):
                buffer = self.blobs.pop(blob_hash)
                if blob_hash in self.completed_blob_hashes:
                    self.completed_blob_hashes.remove(blob_hash)
-                self.blobs[blob_hash] = self._get_blob(blob_hash, length)
+                self.blobs[blob_hash] = self._get_blob(blob_hash, length, is_mine)
                if buffer.is_readable():
                    with buffer.reader_context() as reader:
                        self.blobs[blob_hash].write_blob(reader.read())
            if length and self.blobs[blob_hash].length is None:
                self.blobs[blob_hash].set_length(length)
        else:
-            self.blobs[blob_hash] = self._get_blob(blob_hash, length)
+            self.blobs[blob_hash] = self._get_blob(blob_hash, length, is_mine)
        return self.blobs[blob_hash]
    def is_blob_verified(self, blob_hash: str, length: typing.Optional[int] = None) -> bool:
@ -83,6 +83,8 @@ class BlobManager:
        to_add = await self.storage.sync_missing_blobs(in_blobfiles_dir)
        if to_add:
            self.completed_blob_hashes.update(to_add)
        # check blobs that aren't set as finished but were seen on disk
        await self.ensure_completed_blobs_status(in_blobfiles_dir - to_add)
        if self.config.track_bandwidth:
            self.connection_manager.start()
        return True
@ -105,13 +107,26 @@ class BlobManager:
        if isinstance(blob, BlobFile):
            if blob.blob_hash not in self.completed_blob_hashes:
                self.completed_blob_hashes.add(blob.blob_hash)
-            return self.loop.create_task(self.storage.add_blobs((blob.blob_hash, blob.length), finished=True))
+            return self.loop.create_task(self.storage.add_blobs(
                (blob.blob_hash, blob.length, blob.added_on, blob.is_mine), finished=True)
            )
        else:
-            return self.loop.create_task(self.storage.add_blobs((blob.blob_hash, blob.length), finished=False))
+            return self.loop.create_task(self.storage.add_blobs(
                (blob.blob_hash, blob.length, blob.added_on, blob.is_mine), finished=False)
            )
-    def check_completed_blobs(self, blob_hashes: typing.List[str]) -> typing.List[str]:
+    async def ensure_completed_blobs_status(self, blob_hashes: typing.Iterable[str]):
-        """Returns of the blobhashes_to_check, which are valid"""
+        """Ensures that completed blobs from a given list of blob hashes are set as 'finished' in the database."""
-        return [blob_hash for blob_hash in blob_hashes if self.is_blob_verified(blob_hash)]
+        to_add = []
        for blob_hash in blob_hashes:
            if not self.is_blob_verified(blob_hash):
                continue
            blob = self.get_blob(blob_hash)
            to_add.append((blob.blob_hash, blob.length, blob.added_on, blob.is_mine))
            if len(to_add) > 500:
                await self.storage.add_blobs(*to_add, finished=True)
                to_add.clear()
        return await self.storage.add_blobs(*to_add, finished=True)
    def delete_blob(self, blob_hash: str):
        if not is_valid_blobhash(blob_hash):
--- a/lbry/blob/disk_space_manager.py
+++ b/lbry/blob/disk_space_manager.py
@ -0,0 +1,77 @@
 import asyncio
 import logging
 log = logging.getLogger(__name__)
 class DiskSpaceManager:
    def __init__(self, config, db, blob_manager, cleaning_interval=30 * 60, analytics=None):
        self.config = config
        self.db = db
        self.blob_manager = blob_manager
        self.cleaning_interval = cleaning_interval
        self.running = False
        self.task = None
        self.analytics = analytics
        self._used_space_bytes = None
    async def get_free_space_mb(self, is_network_blob=False):
        limit_mb = self.config.network_storage_limit if is_network_blob else self.config.blob_storage_limit
        space_used_mb = await self.get_space_used_mb()
        space_used_mb = space_used_mb['network_storage'] if is_network_blob else space_used_mb['content_storage']
        return max(0, limit_mb - space_used_mb)
    async def get_space_used_bytes(self):
        self._used_space_bytes = await self.db.get_stored_blob_disk_usage()
        return self._used_space_bytes
    async def get_space_used_mb(self, cached=True):
        cached = cached and self._used_space_bytes is not None
        space_used_bytes = self._used_space_bytes if cached else await self.get_space_used_bytes()
        return {key: int(value/1024.0/1024.0) for key, value in space_used_bytes.items()}
    async def clean(self):
        await self._clean(False)
        await self._clean(True)
    async def _clean(self, is_network_blob=False):
        space_used_mb = await self.get_space_used_mb(cached=False)
        if is_network_blob:
            space_used_mb = space_used_mb['network_storage']
        else:
            space_used_mb = space_used_mb['content_storage'] + space_used_mb['private_storage']
        storage_limit_mb = self.config.network_storage_limit if is_network_blob else self.config.blob_storage_limit
        if self.analytics:
            asyncio.create_task(
                self.analytics.send_disk_space_used(space_used_mb, storage_limit_mb, is_network_blob)
            )
        delete = []
        available = storage_limit_mb - space_used_mb
        if storage_limit_mb == 0 if not is_network_blob else available >= 0:
            return 0
        for blob_hash, file_size, _ in await self.db.get_stored_blobs(is_mine=False, is_network_blob=is_network_blob):
            delete.append(blob_hash)
            available += int(file_size/1024.0/1024.0)
            if available >= 0:
                break
        if delete:
            await self.db.stop_all_files()
            await self.blob_manager.delete_blobs(delete, delete_from_db=True)
        self._used_space_bytes = None
        return len(delete)
    async def cleaning_loop(self):
        while self.running:
            await asyncio.sleep(self.cleaning_interval)
            await self.clean()
    async def start(self):
        self.running = True
        self.task = asyncio.create_task(self.cleaning_loop())
        self.task.add_done_callback(lambda _: log.info("Stopping blob cleanup service."))
    async def stop(self):
        if self.running:
            self.running = False
            self.task.cancel()
--- a/lbry/lbry/blob/writer.py
+++ b/lbry/lbry/blob/writer.py
@ -3,7 +3,7 @@ import logging
 import asyncio
 from io import BytesIO
 from lbry.error import InvalidBlobHashError, InvalidDataError
-from lbry.cryptoutils import get_lbry_hash_obj
+from lbry.utils import get_lbry_hash_obj
 log = logging.getLogger(__name__)
--- a/lbry/lbry/blob_exchange/init.py
+++ b/lbry/lbry/blob_exchange/init.py
--- a/lbry/lbry/blob_exchange/client.py
+++ b/lbry/lbry/blob_exchange/client.py
@ -32,7 +32,7 @@ class BlobExchangeClientProtocol(asyncio.Protocol):
        self.buf = b''
        # this is here to handle the race when the downloader is closed right as response_fut gets a result
-        self.closed = asyncio.Event(loop=self.loop)
+        self.closed = asyncio.Event()
    def data_received(self, data: bytes):
        if self.connection_manager:
@ -95,7 +95,7 @@ class BlobExchangeClientProtocol(asyncio.Protocol):
            if self._response_fut and not self._response_fut.done():
                self._response_fut.set_exception(err)
-    async def _download_blob(self) -> typing.Tuple[int, Optional['BlobExchangeClientProtocol']]:
+    async def _download_blob(self) -> typing.Tuple[int, Optional['BlobExchangeClientProtocol']]:  # pylint: disable=too-many-return-statements
        """
        :return: download success (bool), connected protocol (BlobExchangeClientProtocol)
        """
@ -111,7 +111,7 @@ class BlobExchangeClientProtocol(asyncio.Protocol):
            self.transport.write(msg)
            if self.connection_manager:
                self.connection_manager.sent_data(f"{self.peer_address}:{self.peer_port}", len(msg))
-            response: BlobResponse = await asyncio.wait_for(self._response_fut, self.peer_timeout, loop=self.loop)
+            response: BlobResponse = await asyncio.wait_for(self._response_fut, self.peer_timeout)
            availability_response = response.get_availability_response()
            price_response = response.get_price_response()
            blob_response = response.get_blob_response()
@ -151,7 +151,9 @@ class BlobExchangeClientProtocol(asyncio.Protocol):
                f" timeout in {self.peer_timeout}"
            log.debug(msg)
            msg = f"downloaded {self.blob.blob_hash[:8]} from {self.peer_address}:{self.peer_port}"
-            await asyncio.wait_for(self.writer.finished, self.peer_timeout, loop=self.loop)
+            await asyncio.wait_for(self.writer.finished, self.peer_timeout)
            # wait for the io to finish
            await self.blob.verified.wait()
            log.info("%s at %fMB/s", msg,
                     round((float(self._blob_bytes_received) /
                            float(time.perf_counter() - start_time)) / 1000000.0, 2))
@ -185,7 +187,7 @@ class BlobExchangeClientProtocol(asyncio.Protocol):
        try:
            self._blob_bytes_received = 0
            self.blob, self.writer = blob, blob.get_blob_writer(self.peer_address, self.peer_port)
-            self._response_fut = asyncio.Future(loop=self.loop)
+            self._response_fut = asyncio.Future()
            return await self._download_blob()
        except OSError:
            # i'm not sure how to fix this race condition - jack
@ -213,11 +215,11 @@ class BlobExchangeClientProtocol(asyncio.Protocol):
            self.connection_manager.connection_made(f"{self.peer_address}:{self.peer_port}")
        log.debug("connection made to %s:%i", self.peer_address, self.peer_port)
-    def connection_lost(self, reason):
+    def connection_lost(self, exc):
        if self.connection_manager:
            self.connection_manager.outgoing_connection_lost(f"{self.peer_address}:{self.peer_port}")
-        log.debug("connection lost to %s:%i (reason: %s, %s)", self.peer_address, self.peer_port, str(reason),
+        log.debug("connection lost to %s:%i (reason: %s, %s)", self.peer_address, self.peer_port, str(exc),
-                  str(type(reason)))
+                  str(type(exc)))
        self.close()
@ -242,7 +244,7 @@ async def request_blob(loop: asyncio.AbstractEventLoop, blob: Optional['Abstract
    try:
        if not connected_protocol:
            await asyncio.wait_for(loop.create_connection(lambda: protocol, address, tcp_port),
-                                   peer_connect_timeout, loop=loop)
+                                   peer_connect_timeout)
            connected_protocol = protocol
        if blob is None or blob.get_is_verified() or not blob.is_writeable():
            # blob is None happens when we are just opening a connection
--- a/lbry/lbry/blob_exchange/downloader.py
+++ b/lbry/lbry/blob_exchange/downloader.py
@ -3,6 +3,7 @@ import typing
 import logging
 from lbry.utils import cache_concurrent
 from lbry.blob_exchange.client import request_blob
 from lbry.dht.node import get_kademlia_peers_from_hosts
 if typing.TYPE_CHECKING:
    from lbry.conf import Config
    from lbry.dht.node import Node
@ -29,7 +30,7 @@ class BlobDownloader:
        self.failures: typing.Dict['KademliaPeer', int] = {}
        self.connection_failures: typing.Set['KademliaPeer'] = set()
        self.connections: typing.Dict['KademliaPeer', 'BlobExchangeClientProtocol'] = {}
-        self.is_running = asyncio.Event(loop=self.loop)
+        self.is_running = asyncio.Event()
    def should_race_continue(self, blob: 'AbstractBlob'):
        max_probes = self.config.max_connections_per_download * (1 if self.connections else 10)
@ -63,8 +64,8 @@ class BlobDownloader:
            self.scores[peer] = bytes_received / elapsed if bytes_received and elapsed else 1
    async def new_peer_or_finished(self):
-        active_tasks = list(self.active_connections.values()) + [asyncio.sleep(1)]
+        active_tasks = list(self.active_connections.values()) + [asyncio.create_task(asyncio.sleep(1))]
-        await asyncio.wait(active_tasks, loop=self.loop, return_when='FIRST_COMPLETED')
+        await asyncio.wait(active_tasks, return_when='FIRST_COMPLETED')
    def cleanup_active(self):
        if not self.active_connections and not self.connections:
@ -87,7 +88,6 @@ class BlobDownloader:
        if blob.get_is_verified():
            return blob
        self.is_running.set()
        tried_for_this_blob: typing.Set['KademliaPeer'] = set()
        try:
            while not blob.get_is_verified() and self.is_running.is_set():
                batch: typing.Set['KademliaPeer'] = set(self.connections.keys())
@ -97,24 +97,15 @@ class BlobDownloader:
                    "%s running, %d peers, %d ignored, %d active, %s connections", blob_hash[:6],
                    len(batch), len(self.ignored), len(self.active_connections), len(self.connections)
                )
                re_add: typing.Set['KademliaPeer'] = set()
                for peer in sorted(batch, key=lambda peer: self.scores.get(peer, 0), reverse=True):
                    if peer in self.ignored:
                        continue
-                    if peer in tried_for_this_blob:
+                    if peer in self.active_connections or not self.should_race_continue(blob):
                        continue
                    if peer in self.active_connections:
                        if peer not in re_add:
                            re_add.add(peer)
                        continue
                    if not self.should_race_continue(blob):
                        break
                    log.debug("request %s from %s:%i", blob_hash[:8], peer.address, peer.tcp_port)
                    t = self.loop.create_task(self.request_blob_from_peer(blob, peer, connection_id))
                    self.active_connections[peer] = t
-                    tried_for_this_blob.add(peer)
+                self.peer_queue.put_nowait(list(batch))
                if not re_add:
                    self.peer_queue.put_nowait(list(batch))
                await self.new_peer_or_finished()
                self.cleanup_active()
            log.debug("downloaded %s", blob_hash[:8])
@ -133,11 +124,14 @@ class BlobDownloader:
            protocol.close()
-async def download_blob(loop, config: 'Config', blob_manager: 'BlobManager', node: 'Node',
+async def download_blob(loop, config: 'Config', blob_manager: 'BlobManager', dht_node: 'Node',
                        blob_hash: str) -> 'AbstractBlob':
-    search_queue = asyncio.Queue(loop=loop, maxsize=config.max_connections_per_download)
+    search_queue = asyncio.Queue(maxsize=config.max_connections_per_download)
    search_queue.put_nowait(blob_hash)
-    peer_queue, accumulate_task = node.accumulate_peers(search_queue)
+    peer_queue, accumulate_task = dht_node.accumulate_peers(search_queue)
    fixed_peers = None if not config.fixed_peers else await get_kademlia_peers_from_hosts(config.fixed_peers)
    if fixed_peers:
        loop.call_later(config.fixed_peer_delay, peer_queue.put_nowait, fixed_peers)
    downloader = BlobDownloader(loop, config, blob_manager, peer_queue)
    try:
        return await downloader.download_blob(blob_hash)
--- a/lbry/lbry/blob_exchange/serialization.py
+++ b/lbry/lbry/blob_exchange/serialization.py
@ -46,7 +46,7 @@ class BlobAvailabilityRequest(BlobMessage):
    def __init__(self, requested_blobs: typing.List[str], lbrycrd_address: typing.Optional[bool] = True,
                 **kwargs) -> None:
-        assert len(requested_blobs)
+        assert len(requested_blobs) > 0
        self.requested_blobs = requested_blobs
        self.lbrycrd_address = lbrycrd_address
@ -134,9 +134,9 @@ class BlobErrorResponse(BlobMessage):
        }
-blob_request_types = typing.Union[BlobPriceRequest, BlobAvailabilityRequest, BlobDownloadRequest,
+blob_request_types = typing.Union[BlobPriceRequest, BlobAvailabilityRequest, BlobDownloadRequest,  # pylint: disable=invalid-name
                                  BlobPaymentAddressRequest]
-blob_response_types = typing.Union[BlobPriceResponse, BlobAvailabilityResponse, BlobDownloadResponse,
+blob_response_types = typing.Union[BlobPriceResponse, BlobAvailabilityResponse, BlobDownloadResponse,  # pylint: disable=invalid-name
                                   BlobErrorResponse, BlobPaymentAddressResponse]
@ -157,10 +157,10 @@ def _parse_blob_response(response_msg: bytes) -> typing.Tuple[typing.Optional[ty
        except ValueError:
            continue
        possible_response_keys = {
-                    BlobPaymentAddressResponse.key,
+            BlobPaymentAddressResponse.key,
-                    BlobAvailabilityResponse.key,
+            BlobAvailabilityResponse.key,
-                    BlobPriceResponse.key,
+            BlobPriceResponse.key,
-                    BlobDownloadResponse.key
+            BlobDownloadResponse.key
        }
        if isinstance(response, dict) and response.keys():
            if set(response.keys()).issubset(possible_response_keys):
@ -179,7 +179,7 @@ class BlobRequest:
        return d
    def _get_request(self, request_type: blob_request_types):
-        request = tuple(filter(lambda r: type(r) == request_type, self.requests))
+        request = tuple(filter(lambda r: type(r) == request_type, self.requests))  # pylint: disable=unidiomatic-typecheck
        if request:
            return request[0]
@ -235,7 +235,7 @@ class BlobResponse:
        return d
    def _get_response(self, response_type: blob_response_types):
-        response = tuple(filter(lambda r: type(r) == response_type, self.responses))
+        response = tuple(filter(lambda r: type(r) == response_type, self.responses))  # pylint: disable=unidiomatic-typecheck
        if response:
            return response[0]
@ -280,4 +280,3 @@ class BlobResponse:
                if response_type.key in response
            ])
        return cls(requests, extra)
--- a/lbry/lbry/blob_exchange/server.py
+++ b/lbry/lbry/blob_exchange/server.py
@ -1,6 +1,7 @@
 import asyncio
 import binascii
 import logging
 import socket
 import typing
 from json.decoder import JSONDecodeError
 from lbry.blob_exchange.serialization import BlobResponse, BlobRequest, blob_response_types
@ -24,19 +25,19 @@ class BlobServerProtocol(asyncio.Protocol):
        self.idle_timeout = idle_timeout
        self.transfer_timeout = transfer_timeout
        self.server_task: typing.Optional[asyncio.Task] = None
-        self.started_listening = asyncio.Event(loop=self.loop)
+        self.started_listening = asyncio.Event()
        self.buf = b''
        self.transport: typing.Optional[asyncio.Transport] = None
        self.lbrycrd_address = lbrycrd_address
        self.peer_address_and_port: typing.Optional[str] = None
-        self.started_transfer = asyncio.Event(loop=self.loop)
+        self.started_transfer = asyncio.Event()
-        self.transfer_finished = asyncio.Event(loop=self.loop)
+        self.transfer_finished = asyncio.Event()
        self.close_on_idle_task: typing.Optional[asyncio.Task] = None
    async def close_on_idle(self):
        while self.transport:
            try:
-                await asyncio.wait_for(self.started_transfer.wait(), self.idle_timeout, loop=self.loop)
+                await asyncio.wait_for(self.started_transfer.wait(), self.idle_timeout)
            except asyncio.TimeoutError:
                log.debug("closing idle connection from %s", self.peer_address_and_port)
                return self.close()
@ -96,27 +97,30 @@ class BlobServerProtocol(asyncio.Protocol):
                incoming_blob = {'blob_hash': blob.blob_hash, 'length': blob.length}
                responses.append(BlobDownloadResponse(incoming_blob=incoming_blob))
                self.send_response(responses)
-                bh = blob.blob_hash[:8]
+                blob_hash = blob.blob_hash[:8]
-                log.debug("send %s to %s:%i", bh, peer_address, peer_port)
+                log.debug("send %s to %s:%i", blob_hash, peer_address, peer_port)
                self.started_transfer.set()
                try:
-                    sent = await asyncio.wait_for(blob.sendfile(self), self.transfer_timeout, loop=self.loop)
+                    sent = await asyncio.wait_for(blob.sendfile(self), self.transfer_timeout)
                    if sent and sent > 0:
                        self.blob_manager.connection_manager.sent_data(self.peer_address_and_port, sent)
-                        log.info("sent %s (%i bytes) to %s:%i", bh, sent, peer_address, peer_port)
+                        log.info("sent %s (%i bytes) to %s:%i", blob_hash, sent, peer_address, peer_port)
                    else:
-                        log.debug("stopped sending %s to %s:%i", bh, peer_address, peer_port)
+                        self.close()
-                except (OSError, asyncio.TimeoutError) as err:
+                        log.debug("stopped sending %s to %s:%i", blob_hash, peer_address, peer_port)
                        return
                except (OSError, ValueError, asyncio.TimeoutError) as err:
                    if isinstance(err, asyncio.TimeoutError):
-                        log.debug("timed out sending blob %s to %s", bh, peer_address)
+                        log.debug("timed out sending blob %s to %s", blob_hash, peer_address)
                    else:
-                        log.warning("could not read blob %s to send %s:%i", bh, peer_address, peer_port)
+                        log.warning("could not read blob %s to send %s:%i", blob_hash, peer_address, peer_port)
                    self.close()
                    return
                finally:
                    self.transfer_finished.set()
            else:
                log.info("don't have %s to send %s:%i", blob.blob_hash[:8], peer_address, peer_port)
-        if responses:
+        if responses and not self.transport.is_closing():
            self.send_response(responses)
    def data_received(self, data):
@ -127,14 +131,14 @@ class BlobServerProtocol(asyncio.Protocol):
            return
        if data:
            self.blob_manager.connection_manager.received_data(self.peer_address_and_port, len(data))
-            message, separator, remainder = data.rpartition(b'}')
+            _, separator, remainder = data.rpartition(b'}')
            if not separator:
                self.buf += data
                return
            try:
                request = BlobRequest.deserialize(self.buf + data)
                self.buf = remainder
-            except JSONDecodeError:
+            except (UnicodeDecodeError, JSONDecodeError):
                log.error("request from %s is not valid json (%i bytes): %s", self.peer_address_and_port,
                          len(self.buf + data), '' if not data else binascii.hexlify(self.buf + data).decode())
                self.close()
@ -153,7 +157,7 @@ class BlobServer:
        self.loop = loop
        self.blob_manager = blob_manager
        self.server_task: typing.Optional[asyncio.Task] = None
-        self.started_listening = asyncio.Event(loop=self.loop)
+        self.started_listening = asyncio.Event()
        self.lbrycrd_address = lbrycrd_address
        self.idle_timeout = idle_timeout
        self.transfer_timeout = transfer_timeout
@ -164,6 +168,13 @@ class BlobServer:
            raise Exception("already running")
        async def _start_server():
            # checking if the port is in use
            # thx https://stackoverflow.com/a/52872579
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                if s.connect_ex(('localhost', port)) == 0:
                    # the port is already in use!
                    log.error("Failed to bind TCP %s:%d", interface, port)
            server = await self.loop.create_server(
                lambda: self.server_protocol_class(self.loop, self.blob_manager, self.lbrycrd_address,
                                                   self.idle_timeout, self.transfer_timeout),
--- a/lbry/lbry/build_type.py
+++ b/lbry/lbry/build_type.py
@ -1,3 +1,4 @@
 # don't touch this. CI server changes this during build/deployment
 BUILD = "dev"
-BUILD_COMMIT = "source installation"
+COMMIT_HASH = "none"
 DOCKER_TAG = "none"
--- a/lbry/lbry/conf.py
+++ b/lbry/lbry/conf.py
@ -1,21 +1,21 @@
 import os
 import re
 import sys
 import typing
 import logging
-import yaml
+from typing import List, Dict, Tuple, Union, TypeVar, Generic, Optional
 from argparse import ArgumentParser
 from contextlib import contextmanager
 from appdirs import user_data_dir, user_config_dir
 import yaml
 from lbry.error import InvalidCurrencyError
 from lbry.dht import constants
-from torba.client.coinselection import STRATEGIES
+from lbry.wallet.coinselection import STRATEGIES
 log = logging.getLogger(__name__)
-NOT_SET = type('NOT_SET', (object,), {})
+NOT_SET = type('NOT_SET', (object,), {})  # pylint: disable=invalid-name
-T = typing.TypeVar('T')
+T = TypeVar('T')
 CURRENCIES = {
    'BTC': {'type': 'crypto'},
@ -24,18 +24,18 @@ CURRENCIES = {
 }
-class Setting(typing.Generic[T]):
+class Setting(Generic[T]):
-    def __init__(self, doc: str, default: typing.Optional[T] = None,
+    def __init__(self, doc: str, default: Optional[T] = None,
-                 previous_names: typing.Optional[typing.List[str]] = None,
+                 previous_names: Optional[List[str]] = None,
-                 metavar: typing.Optional[str] = None):
+                 metavar: Optional[str] = None):
        self.doc = doc
        self.default = default
        self.previous_names = previous_names or []
        self.metavar = metavar
    def __set_name__(self, owner, name):
-        self.name = name
+        self.name = name  # pylint: disable=attribute-defined-outside-init
    @property
    def cli_name(self):
@ -45,7 +45,7 @@ class Setting(typing.Generic[T]):
    def no_cli_name(self):
        return f"--no-{self.name.replace('_', '-')}"
-    def __get__(self, obj: typing.Optional['BaseConfig'], owner) -> T:
+    def __get__(self, obj: Optional['BaseConfig'], owner) -> T:
        if obj is None:
            return self
        for location in obj.search_order:
@ -53,7 +53,7 @@ class Setting(typing.Generic[T]):
                return location[self.name]
        return self.default
-    def __set__(self, obj: 'BaseConfig', val: typing.Union[T, NOT_SET]):
+    def __set__(self, obj: 'BaseConfig', val: Union[T, NOT_SET]):
        if val == NOT_SET:
            for location in obj.modify_order:
                if self.name in location:
@ -63,13 +63,25 @@ class Setting(typing.Generic[T]):
            for location in obj.modify_order:
                location[self.name] = val
-    def validate(self, val):
+    def is_set(self, obj: 'BaseConfig') -> bool:
        for location in obj.search_order:
            if self.name in location:
                return True
        return False
    def is_set_to_default(self, obj: 'BaseConfig') -> bool:
        for location in obj.search_order:
            if self.name in location:
                return location[self.name] == self.default
        return False
    def validate(self, value):
        raise NotImplementedError()
-    def deserialize(self, value):
+    def deserialize(self, value):  # pylint: disable=no-self-use
        return value
-    def serialize(self, value):
+    def serialize(self, value):  # pylint: disable=no-self-use
        return value
    def contribute_to_argparse(self, parser: ArgumentParser):
@ -82,14 +94,18 @@ class Setting(typing.Generic[T]):
 class String(Setting[str]):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, str), \
+        assert isinstance(value, str), \
            f"Setting '{self.name}' must be a string."
    # TODO: removes this after pylint starts to understand generics
    def __get__(self, obj: Optional['BaseConfig'], owner) -> str:  # pylint: disable=useless-super-delegation
        return super().__get__(obj, owner)
 class Integer(Setting[int]):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, int), \
+        assert isinstance(value, int), \
            f"Setting '{self.name}' must be an integer."
    def deserialize(self, value):
@ -97,8 +113,8 @@ class Integer(Setting[int]):
 class Float(Setting[float]):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, float), \
+        assert isinstance(value, float), \
            f"Setting '{self.name}' must be a decimal."
    def deserialize(self, value):
@ -106,8 +122,8 @@ class Float(Setting[float]):
 class Toggle(Setting[bool]):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, bool), \
+        assert isinstance(value, bool), \
            f"Setting '{self.name}' must be a true/false value."
    def contribute_to_argparse(self, parser: ArgumentParser):
@ -127,10 +143,10 @@ class Toggle(Setting[bool]):
 class Path(String):
-    def __init__(self, doc: str, default: str = '', *args, **kwargs):
+    def __init__(self, doc: str, *args, default: str = '', **kwargs):
        super().__init__(doc, default, *args, **kwargs)
-    def __get__(self, obj, owner):
+    def __get__(self, obj, owner) -> str:
        value = super().__get__(obj, owner)
        if isinstance(value, str):
            return os.path.expanduser(os.path.expandvars(value))
@ -187,7 +203,7 @@ class MaxKeyFee(Setting[dict]):
        )
        parser.add_argument(
            self.no_cli_name,
-            help=f"Disable maximum key fee check.",
+            help="Disable maximum key fee check.",
            dest=self.name,
            const=None,
            action="store_const",
@ -196,7 +212,7 @@ class MaxKeyFee(Setting[dict]):
 class StringChoice(String):
-    def __init__(self, doc: str, valid_values: typing.List[str], default: str, *args, **kwargs):
+    def __init__(self, doc: str, valid_values: List[str], default: str, *args, **kwargs):
        super().__init__(doc, default, *args, **kwargs)
        if not valid_values:
            raise ValueError("No valid values provided")
@ -204,16 +220,16 @@ class StringChoice(String):
            raise ValueError(f"Default value must be one of: {', '.join(valid_values)}")
        self.valid_values = valid_values
-    def validate(self, val):
+    def validate(self, value):
-        super().validate(val)
+        super().validate(value)
-        if val not in self.valid_values:
+        if value not in self.valid_values:
            raise ValueError(f"Setting '{self.name}' value must be one of: {', '.join(self.valid_values)}")
 class ListSetting(Setting[list]):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, (tuple, list)), \
+        assert isinstance(value, (tuple, list)), \
            f"Setting '{self.name}' must be a tuple or list."
    def contribute_to_argparse(self, parser: ArgumentParser):
@ -226,10 +242,10 @@ class ListSetting(Setting[list]):
 class Servers(ListSetting):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, (tuple, list)), \
+        assert isinstance(value, (tuple, list)), \
            f"Setting '{self.name}' must be a tuple or list of servers."
-        for idx, server in enumerate(val):
+        for idx, server in enumerate(value):
            assert isinstance(server, (tuple, list)) and len(server) == 2, \
                f"Server defined '{server}' at index {idx} in setting " \
                f"'{self.name}' must be a tuple or list of two items."
@ -260,26 +276,104 @@ class Servers(ListSetting):
 class Strings(ListSetting):
-    def validate(self, val):
+    def validate(self, value):
-        assert isinstance(val, (tuple, list)), \
+        assert isinstance(value, (tuple, list)), \
            f"Setting '{self.name}' must be a tuple or list of strings."
-        for idx, string in enumerate(val):
+        for idx, string in enumerate(value):
            assert isinstance(string, str), \
                f"Value of '{string}' at index {idx} in setting " \
                f"'{self.name}' must be a string."
 class KnownHubsList:
    def __init__(self, config: 'Config' = None, file_name: str = 'known_hubs.yml'):
        self.file_name = file_name
        self.path = os.path.join(config.wallet_dir, self.file_name) if config else None
        self.hubs: Dict[Tuple[str, int], Dict] = {}
        if self.exists:
            self.load()
    @property
    def exists(self):
        return self.path and os.path.exists(self.path)
    @property
    def serialized(self) -> Dict[str, Dict]:
        return {f"{host}:{port}": details for (host, port), details in self.hubs.items()}
    def filter(self, match_none=False, **kwargs):
        if not kwargs:
            return self.hubs
        result = {}
        for hub, details in self.hubs.items():
            for key, constraint in kwargs.items():
                value = details.get(key)
                if value == constraint or (match_none and value is None):
                    result[hub] = details
                    break
        return result
    def load(self):
        if self.path:
            with open(self.path, 'r') as known_hubs_file:
                raw = known_hubs_file.read()
                for hub, details in yaml.safe_load(raw).items():
                    self.set(hub, details)
    def save(self):
        if self.path:
            with open(self.path, 'w') as known_hubs_file:
                known_hubs_file.write(yaml.safe_dump(self.serialized, default_flow_style=False))
    def set(self, hub: str, details: Dict):
        if hub and hub.count(':') == 1:
            host, port = hub.split(':')
            hub_parts = (host, int(port))
            if hub_parts not in self.hubs:
                self.hubs[hub_parts] = details
                return hub
    def add_hubs(self, hubs: List[str]):
        added = False
        for hub in hubs:
            if self.set(hub, {}) is not None:
                added = True
        return added
    def items(self):
        return self.hubs.items()
    def __bool__(self):
        return len(self) > 0
    def __len__(self):
        return self.hubs.__len__()
    def __iter__(self):
        return iter(self.hubs)
 class EnvironmentAccess:
    PREFIX = 'LBRY_'
-    def __init__(self, environ: dict):
+    def __init__(self, config: 'BaseConfig', environ: dict):
-        self.environ = environ
+        self.configuration = config
        self.data = {}
        if environ:
            self.load(environ)
    def load(self, environ):
        for setting in self.configuration.get_settings():
            value = environ.get(f'{self.PREFIX}{setting.name.upper()}', NOT_SET)
            if value != NOT_SET and not (isinstance(setting, ListSetting) and value is None):
                self.data[setting.name] = setting.deserialize(value)
    def __contains__(self, item: str):
-        return f'{self.PREFIX}{item.upper()}' in self.environ
+        return item in self.data
    def __getitem__(self, item: str):
-        return self.environ[f'{self.PREFIX}{item.upper()}']
+        return self.data[item]
 class ArgumentAccess:
@ -320,7 +414,7 @@ class ConfigFileAccess:
        cls = type(self.configuration)
        with open(self.path, 'r') as config_file:
            raw = config_file.read()
-        serialized = yaml.load(raw) or {}
+        serialized = yaml.safe_load(raw) or {}
        for key, value in serialized.items():
            attr = getattr(cls, key, None)
            if attr is None:
@ -364,7 +458,7 @@ class ConfigFileAccess:
        del self.data[key]
-TBC = typing.TypeVar('TBC', bound='BaseConfig')
+TBC = TypeVar('TBC', bound='BaseConfig')
 class BaseConfig:
@ -438,7 +532,7 @@ class BaseConfig:
        self.arguments = ArgumentAccess(self, args)
    def set_environment(self, environ=None):
-        self.environment = EnvironmentAccess(environ or os.environ)
+        self.environment = EnvironmentAccess(self, environ or os.environ)
    def set_persisted(self, config_file_path=None):
        if config_file_path is None:
@ -457,7 +551,27 @@ class BaseConfig:
            self.persisted.save()
-class CLIConfig(BaseConfig):
+class TranscodeConfig(BaseConfig):
    ffmpeg_path = String('A list of places to check for ffmpeg and ffprobe. '
                         f'$data_dir/ffmpeg/bin and $PATH are checked afterward. Separator: {os.pathsep}',
                         '', previous_names=['ffmpeg_folder'])
    video_encoder = String('FFmpeg codec and parameters for the video encoding. '
                           'Example: libaom-av1 -crf 25 -b:v 0 -strict experimental',
                           'libx264 -crf 24 -preset faster -pix_fmt yuv420p')
    video_bitrate_maximum = Integer('Maximum bits per second allowed for video streams (0 to disable).', 5_000_000)
    video_scaler = String('FFmpeg scaling parameters for reducing bitrate. '
                          'Example: -vf "scale=-2:720,fps=24" -maxrate 5M -bufsize 3M',
                          r'-vf "scale=if(gte(iw\,ih)\,min(1920\,iw)\,-2):if(lt(iw\,ih)\,min(1920\,ih)\,-2)" '
                          r'-maxrate 5500K -bufsize 5000K')
    audio_encoder = String('FFmpeg codec and parameters for the audio encoding. '
                           'Example: libopus -b:a 128k',
                           'aac -b:a 160k')
    volume_filter = String('FFmpeg filter for audio normalization. Exmple: -af loudnorm', '')
    volume_analysis_time = Integer('Maximum seconds into the file that we examine audio volume (0 to disable).', 240)
 class CLIConfig(TranscodeConfig):
    api = String('Host name and port for lbrynet daemon API.', 'localhost:5279', metavar='HOST:PORT')
@ -475,6 +589,9 @@ class CLIConfig(BaseConfig):
 class Config(CLIConfig):
    jurisdiction = String("Limit interactions to wallet server in this jurisdiction.")
    # directories
    data_dir = Path("Directory path to store blobs.", metavar='DIR')
    download_dir = Path(
@ -496,7 +613,8 @@ class Config(CLIConfig):
        "ports or have firewall rules you likely want to disable this.", True
    )
    udp_port = Integer("UDP port for communicating on the LBRY DHT", 4444, previous_names=['dht_node_port'])
-    tcp_port = Integer("TCP port to listen for incoming blob requests", 3333, previous_names=['peer_port'])
+    tcp_port = Integer("TCP port to listen for incoming blob requests", 4444, previous_names=['peer_port'])
    prometheus_port = Integer("Port to expose prometheus metrics (off by default)", 0)
    network_interface = String("Interface to use for the DHT and blob exchange", '0.0.0.0')
    # routing table
@ -504,17 +622,24 @@ class Config(CLIConfig):
        "Routing table bucket index below which we always split the bucket if given a new key to add to it and "
        "the bucket is full. As this value is raised the depth of the routing table (and number of peers in it) "
        "will increase. This setting is used by seed nodes, you probably don't want to change it during normal "
-        "use.", 1
+        "use.", 2
    )
    is_bootstrap_node = Toggle(
        "When running as a bootstrap node, disable all logic related to balancing the routing table, so we can "
        "add as many peers as possible and better help first-runs.", False
    )
    # protocol timeouts
    download_timeout = Float("Cumulative timeout for a stream to begin downloading before giving up", 30.0)
    blob_download_timeout = Float("Timeout to download a blob from a peer", 30.0)
    hub_timeout = Float("Timeout when making a hub request", 30.0)
    peer_connect_timeout = Float("Timeout to establish a TCP connection to a peer", 3.0)
-    node_rpc_timeout = Float("Timeout when making a DHT request", constants.rpc_timeout)
+    node_rpc_timeout = Float("Timeout when making a DHT request", constants.RPC_TIMEOUT)
    # blob announcement and download
    save_blobs = Toggle("Save encrypted blob files for hosting, otherwise download blobs to memory only.", True)
    network_storage_limit = Integer("Disk space in MB to be allocated for helping the P2P network. 0 = disable", 0)
    blob_storage_limit = Integer("Disk space in MB to be allocated for blob storage. 0 = no limit", 0)
    blob_lru_cache_size = Integer(
        "LRU cache size for decrypted downloaded blobs used to minimize re-downloading the same blobs when "
        "replying to a range request. Set to 0 to disable.", 32
@ -531,6 +656,7 @@ class Config(CLIConfig):
        "Maximum number of peers to connect to while downloading a blob", 4,
        previous_names=['max_connections_per_stream']
    )
    concurrent_hub_requests = Integer("Maximum number of concurrent hub requests", 32)
    fixed_peer_delay = Float(
        "Amount of seconds before adding the reflector servers as potential peers to download from in case dht"
        "peers are not found or are slow", 2.0
@ -539,6 +665,7 @@ class Config(CLIConfig):
        "Don't download streams with fees exceeding this amount. When set to "
        "null, the amount is unbounded.", {'currency': 'USD', 'amount': 50.0}
    )
    max_wallet_server_fee = String("Maximum daily LBC amount allowed as payment for wallet servers.", "0.0")
    # reflector settings
    reflect_streams = Toggle(
@ -550,42 +677,62 @@ class Config(CLIConfig):
    )
    # servers
-    reflector_servers = Servers("Reflector re-hosting servers", [
+    reflector_servers = Servers("Reflector re-hosting servers for mirroring publishes", [
        ('reflector.lbry.com', 5566)
    ])
    fixed_peers = Servers("Fixed peers to fall back to if none are found on P2P for a blob", [
        ('cdn.reflector.lbry.com', 5567)
    ])
    tracker_servers = Servers("BitTorrent-compatible (BEP15) UDP trackers for helping P2P discovery", [
        ('tracker.lbry.com', 9252),
        ('tracker.lbry.grin.io', 9252),
        ('tracker.lbry.pigg.es', 9252),
        ('tracker.lizard.technology', 9252),
        ('s1.lbry.network', 9252),
    ])
    lbryum_servers = Servers("SPV wallet servers", [
-        ('spv1.lbry.com', 50001),
+        ('spv11.lbry.com', 50001),
-        ('spv2.lbry.com', 50001),
+        ('spv12.lbry.com', 50001),
-        ('spv3.lbry.com', 50001),
+        ('spv13.lbry.com', 50001),
-        ('spv4.lbry.com', 50001),
+        ('spv14.lbry.com', 50001),
-        ('spv5.lbry.com', 50001),
+        ('spv15.lbry.com', 50001),
-        ('spv6.lbry.com', 50001),
+        ('spv16.lbry.com', 50001),
-        ('spv7.lbry.com', 50001),
+        ('spv17.lbry.com', 50001),
-        ('spv8.lbry.com', 50001),
+        ('spv18.lbry.com', 50001),
-        ('spv9.lbry.com', 50001),
+        ('spv19.lbry.com', 50001),
        ('hub.lbry.grin.io', 50001),
        ('hub.lizard.technology', 50001),
        ('s1.lbry.network', 50001),
    ])
    known_dht_nodes = Servers("Known nodes for bootstrapping connection to the DHT", [
        ('dht.lbry.grin.io', 4444),  # Grin
        ('dht.lbry.madiator.com', 4444),  # Madiator
        ('dht.lbry.pigg.es', 4444), # Pigges
        ('lbrynet1.lbry.com', 4444),  # US EAST
        ('lbrynet2.lbry.com', 4444),  # US WEST
        ('lbrynet3.lbry.com', 4444),  # EU
-        ('lbrynet4.lbry.com', 4444)  # ASIA
+        ('lbrynet4.lbry.com', 4444),  # ASIA
        ('dht.lizard.technology', 4444),  # Jack
        ('s2.lbry.network', 4444),
    ])
    comment_server = String("Comment server API URL", "https://comments.lbry.com/api")
    # blockchain
    blockchain_name = String("Blockchain name - lbrycrd_main, lbrycrd_regtest, or lbrycrd_testnet", 'lbrycrd_main')
    s3_headers_depth = Integer("download headers from s3 when the local height is more than 10 chunks behind", 96 * 10)
    cache_time = Integer("Time to cache resolved claims", 150)  # TODO: use this
    # daemon
-    save_files = Toggle("Save downloaded files when calling `get` by default", True)
+    save_files = Toggle("Save downloaded files when calling `get` by default", False)
    components_to_skip = Strings("components which will be skipped during start-up of daemon", [])
    share_usage_data = Toggle(
-        "Whether to share usage stats and diagnostic info with LBRY.", True,
+        "Whether to share usage stats and diagnostic info with LBRY.", False,
        previous_names=['upload_log', 'upload_log', 'share_debug_info']
    )
    track_bandwidth = Toggle("Track bandwidth usage", True)
    allowed_origin = String(
        "Allowed `Origin` header value for API request (sent by browser), use * to allow "
        "all hosts; default is to only allow API requests with no `Origin` value.", "")
    # media server
    streaming_server = String('Host name and port to serve streaming media over range requests',
@ -595,7 +742,14 @@ class Config(CLIConfig):
    coin_selection_strategy = StringChoice(
        "Strategy to use when selecting UTXOs for a transaction",
-        STRATEGIES, "standard")
+        STRATEGIES, "prefer_confirmed"
    )
    transaction_cache_size = Integer("Transaction cache size", 2 ** 17)
    save_resolved_claims = Toggle(
        "Save content claims to the database when they are resolved to keep file_list up to date, "
        "only disable this if file_x commands are not needed", True
    )
    @property
    def streaming_host(self):
@ -608,6 +762,7 @@ class Config(CLIConfig):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.set_default_paths()
        self.known_hubs = KnownHubsList(self)
    def set_default_paths(self):
        if 'darwin' in sys.platform.lower():
@ -629,7 +784,7 @@ class Config(CLIConfig):
        return os.path.join(self.data_dir, 'lbrynet.log')
-def get_windows_directories() -> typing.Tuple[str, str, str]:
+def get_windows_directories() -> Tuple[str, str, str]:
    from lbry.winpaths import get_path, FOLDERID, UserHandle, \
        PathNotFoundException  # pylint: disable=import-outside-toplevel
@ -651,19 +806,20 @@ def get_windows_directories() -> typing.Tuple[str, str, str]:
    return data_dir, lbryum_dir, download_dir
-def get_darwin_directories() -> typing.Tuple[str, str, str]:
+def get_darwin_directories() -> Tuple[str, str, str]:
    data_dir = user_data_dir('LBRY')
    lbryum_dir = os.path.expanduser('~/.lbryum')
    download_dir = os.path.expanduser('~/Downloads')
    return data_dir, lbryum_dir, download_dir
-def get_linux_directories() -> typing.Tuple[str, str, str]:
+def get_linux_directories() -> Tuple[str, str, str]:
    try:
        with open(os.path.join(user_config_dir(), 'user-dirs.dirs'), 'r') as xdg:
-            down_dir = re.search(r'XDG_DOWNLOAD_DIR=(.+)', xdg.read()).group(1)
+            down_dir = re.search(r'XDG_DOWNLOAD_DIR=(.+)', xdg.read())
-        down_dir = re.sub(r'\$HOME', os.getenv('HOME') or os.path.expanduser("~/"), down_dir)
+        if down_dir:
-        download_dir = re.sub('\"', '', down_dir)
+            down_dir = re.sub(r'\$HOME', os.getenv('HOME') or os.path.expanduser("~/"), down_dir.group(1))
            download_dir = re.sub('\"', '', down_dir)
    except OSError:
        download_dir = os.getenv('XDG_DOWNLOAD_DIR')
    if not download_dir:
--- a/lbry/lbry/connection_manager.py
+++ b/lbry/lbry/connection_manager.py
@ -67,18 +67,18 @@ class ConnectionManager:
        while True:
            last = time.perf_counter()
-            await asyncio.sleep(0.1, loop=self.loop)
+            await asyncio.sleep(0.1)
            self._status['incoming_bps'].clear()
            self._status['outgoing_bps'].clear()
            now = time.perf_counter()
            while self.outgoing:
-                k, v = self.outgoing.popitem()
+                k, sent = self.outgoing.popitem()
-                self._status['total_sent'] += v
+                self._status['total_sent'] += sent
-                self._status['outgoing_bps'][k] = v / (now - last)
+                self._status['outgoing_bps'][k] = sent / (now - last)
            while self.incoming:
-                k, v = self.incoming.popitem()
+                k, received = self.incoming.popitem()
-                self._status['total_received'] += v
+                self._status['total_received'] += received
-                self._status['incoming_bps'][k] = v / (now - last)
+                self._status['incoming_bps'][k] = received / (now - last)
            self._status['total_outgoing_mbs'] = int(sum(list(self._status['outgoing_bps'].values())
                                                         )) / 1000000.0
            self._status['total_incoming_mbs'] = int(sum(list(self._status['incoming_bps'].values())
--- a/lbry/constants.py
+++ b/lbry/constants.py
@ -0,0 +1,2 @@
 CENT = 1000000
 COIN = 100*CENT
--- a/lbry/lbry/dht/init.py
+++ b/lbry/lbry/dht/init.py
--- a/lbry/crypto/base58.py
+++ b/lbry/crypto/base58.py
@ -0,0 +1,86 @@
 from lbry.crypto.hash import double_sha256
 from lbry.crypto.util import bytes_to_int, int_to_bytes
 class Base58Error(Exception):
    """ Exception used for Base58 errors. """
 class Base58:
    """ Class providing base 58 functionality. """
    chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    assert len(chars) == 58
    char_map = {c: n for n, c in enumerate(chars)}
    @classmethod
    def char_value(cls, c):
        val = cls.char_map.get(c)
        if val is None:
            raise Base58Error(f'invalid base 58 character "{c}"')
        return val
    @classmethod
    def decode(cls, txt):
        """ Decodes txt into a big-endian bytearray. """
        if isinstance(txt, memoryview):
            txt = str(txt)
        if isinstance(txt, bytes):
            txt = txt.decode()
        if not isinstance(txt, str):
            raise TypeError('a string is required')
        if not txt:
            raise Base58Error('string cannot be empty')
        value = 0
        for c in txt:
            value = value * 58 + cls.char_value(c)
        result = int_to_bytes(value)
        # Prepend leading zero bytes if necessary
        count = 0
        for c in txt:
            if c != '1':
                break
            count += 1
        if count:
            result = bytes((0,)) * count + result
        return result
    @classmethod
    def encode(cls, be_bytes):
        """Converts a big-endian bytearray into a base58 string."""
        value = bytes_to_int(be_bytes)
        txt = ''
        while value:
            value, mod = divmod(value, 58)
            txt += cls.chars[mod]
        for byte in be_bytes:
            if byte != 0:
                break
            txt += '1'
        return txt[::-1]
    @classmethod
    def decode_check(cls, txt, hash_fn=double_sha256):
        """ Decodes a Base58Check-encoded string to a payload. The version prefixes it. """
        be_bytes = cls.decode(txt)
        result, check = be_bytes[:-4], be_bytes[-4:]
        if check != hash_fn(result)[:4]:
            raise Base58Error(f'invalid base 58 checksum for {txt}')
        return result
    @classmethod
    def encode_check(cls, payload, hash_fn=double_sha256):
        """ Encodes a payload bytearray (which includes the version byte(s))
            into a Base58Check string."""
        be_bytes = payload + hash_fn(payload)[:4]
        return cls.encode(be_bytes)
--- a/lbry/crypto/crypt.py
+++ b/lbry/crypto/crypt.py
@ -0,0 +1,71 @@
 import os
 import base64
 import typing
 from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
 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 lbry.error import InvalidPasswordError
 from lbry.crypto.hash import double_sha256
 def aes_encrypt(secret: str, value: str, init_vector: bytes = None) -> str:
    if init_vector is not None:
        assert len(init_vector) == 16
    else:
        init_vector = os.urandom(16)
    key = double_sha256(secret.encode())
    encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor()
    padder = PKCS7(AES.block_size).padder()
    padded_data = padder.update(value.encode()) + padder.finalize()
    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()
    return base64.b64encode(init_vector + encrypted_data).decode()
 def aes_decrypt(secret: str, value: str) -> typing.Tuple[str, bytes]:
    try:
        data = base64.b64decode(value.encode())
        key = double_sha256(secret.encode())
        init_vector, data = data[:16], data[16:]
        decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor()
        unpadder = PKCS7(AES.block_size).unpadder()
        result = unpadder.update(decryptor.update(data)) + unpadder.finalize()
        return result.decode(), init_vector
    except UnicodeDecodeError:
        raise InvalidPasswordError()
    except ValueError as e:
        if e.args[0] == 'Invalid padding bytes.':
            raise InvalidPasswordError()
        raise
 def better_aes_encrypt(secret: str, value: bytes) -> bytes:
    init_vector = os.urandom(16)
    key = scrypt(secret.encode(), salt=init_vector)
    encryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).encryptor()
    padder = PKCS7(AES.block_size).padder()
    padded_data = padder.update(value) + padder.finalize()
    encrypted_data = encryptor.update(padded_data) + encryptor.finalize()
    return base64.b64encode(b's:8192:16:1:' + init_vector + encrypted_data)
 def better_aes_decrypt(secret: str, value: bytes) -> bytes:
    try:
        data = base64.b64decode(value)
        _, scryp_n, scrypt_r, scrypt_p, data = data.split(b':', maxsplit=4)
        init_vector, data = data[:16], data[16:]
        key = scrypt(secret.encode(), init_vector, int(scryp_n), int(scrypt_r), int(scrypt_p))
        decryptor = Cipher(AES(key), modes.CBC(init_vector), default_backend()).decryptor()
        unpadder = PKCS7(AES.block_size).unpadder()
        return unpadder.update(decryptor.update(data)) + unpadder.finalize()
    except ValueError as e:
        if e.args[0] == 'Invalid padding bytes.':
            raise InvalidPasswordError()
        raise
 def scrypt(passphrase, salt, scrypt_n=1<<13, scrypt_r=16, scrypt_p=1):
    kdf = Scrypt(salt, length=32, n=scrypt_n, r=scrypt_r, p=scrypt_p, backend=default_backend())
    return kdf.derive(passphrase)
--- a/lbry/crypto/hash.py
+++ b/lbry/crypto/hash.py
@ -0,0 +1,47 @@
 import hashlib
 import hmac
 from binascii import hexlify, unhexlify
 def sha256(x):
    """ Simple wrapper of hashlib sha256. """
    return hashlib.sha256(x).digest()
 def sha512(x):
    """ Simple wrapper of hashlib sha512. """
    return hashlib.sha512(x).digest()
 def ripemd160(x):
    """ Simple wrapper of hashlib ripemd160. """
    h = hashlib.new('ripemd160')
    h.update(x)
    return h.digest()
 def double_sha256(x):
    """ SHA-256 of SHA-256, as used extensively in bitcoin. """
    return sha256(sha256(x))
 def hmac_sha512(key, msg):
    """ Use SHA-512 to provide an HMAC. """
    return hmac.new(key, msg, hashlib.sha512).digest()
 def hash160(x):
    """ RIPEMD-160 of SHA-256.
        Used to make bitcoin addresses from pubkeys. """
    return ripemd160(sha256(x))
 def hash_to_hex_str(x):
    """ Convert a big-endian binary hash to displayed hex string.
        Display form of a binary hash is reversed and converted to hex. """
    return hexlify(reversed(x))
 def hex_str_to_hash(x):
    """ Convert a displayed hex string to a binary hash. """
    return reversed(unhexlify(x))
--- a/lbry/crypto/util.py
+++ b/lbry/crypto/util.py
@ -0,0 +1,13 @@
 from binascii import unhexlify, hexlify
 def bytes_to_int(be_bytes):
    """ Interprets a big-endian sequence of bytes as an integer. """
    return int(hexlify(be_bytes), 16)
 def int_to_bytes(value):
    """ Converts an integer to a big-endian sequence of bytes. """
    length = (value.bit_length() + 7) // 8
    s = '%x' % value
    return unhexlify(('0' * (len(s) % 2) + s).zfill(length * 2))
--- a/lbry/lbry/dht/protocol/init.py
+++ b/lbry/lbry/dht/protocol/init.py
--- a/lbry/dht/blob_announcer.py
+++ b/lbry/dht/blob_announcer.py
@ -0,0 +1,78 @@
 import asyncio
 import typing
 import logging
 from prometheus_client import Counter, Gauge
 if typing.TYPE_CHECKING:
    from lbry.dht.node import Node
    from lbry.extras.daemon.storage import SQLiteStorage
 log = logging.getLogger(__name__)
 class BlobAnnouncer:
    announcements_sent_metric = Counter(
        "announcements_sent", "Number of announcements sent and their respective status.", namespace="dht_node",
        labelnames=("peers", "error"),
    )
    announcement_queue_size_metric = Gauge(
        "announcement_queue_size", "Number of hashes waiting to be announced.", namespace="dht_node",
        labelnames=("scope",)
    )
    def __init__(self, loop: asyncio.AbstractEventLoop, node: 'Node', storage: 'SQLiteStorage'):
        self.loop = loop
        self.node = node
        self.storage = storage
        self.announce_task: asyncio.Task = None
        self.announce_queue: typing.List[str] = []
        self._done = asyncio.Event()
        self.announced = set()
    async def _run_consumer(self):
        while self.announce_queue:
            try:
                blob_hash = self.announce_queue.pop()
                peers = len(await self.node.announce_blob(blob_hash))
                self.announcements_sent_metric.labels(peers=peers, error=False).inc()
                if peers > 4:
                    self.announced.add(blob_hash)
                else:
                    log.debug("failed to announce %s, could only find %d peers, retrying soon.", blob_hash[:8], peers)
            except Exception as err:
                self.announcements_sent_metric.labels(peers=0, error=True).inc()
                log.warning("error announcing %s: %s", blob_hash[:8], str(err))
    async def _announce(self, batch_size: typing.Optional[int] = 10):
        while batch_size:
            if not self.node.joined.is_set():
                await self.node.joined.wait()
            await asyncio.sleep(60)
            if not self.node.protocol.routing_table.get_peers():
                log.warning("No peers in DHT, announce round skipped")
                continue
            self.announce_queue.extend(await self.storage.get_blobs_to_announce())
            self.announcement_queue_size_metric.labels(scope="global").set(len(self.announce_queue))
            log.debug("announcer task wake up, %d blobs to announce", len(self.announce_queue))
            while len(self.announce_queue) > 0:
                log.info("%i blobs to announce", len(self.announce_queue))
                await asyncio.gather(*[self._run_consumer() for _ in range(batch_size)])
                announced = list(filter(None, self.announced))
                if announced:
                    await self.storage.update_last_announced_blobs(announced)
                    log.info("announced %i blobs", len(announced))
                    self.announced.clear()
            self._done.set()
            self._done.clear()
    def start(self, batch_size: typing.Optional[int] = 10):
        assert not self.announce_task or self.announce_task.done(), "already running"
        self.announce_task = self.loop.create_task(self._announce(batch_size))
    def stop(self):
        if self.announce_task and not self.announce_task.done():
            self.announce_task.cancel()
    def wait(self):
        return self._done.wait()
--- a/lbry/dht/constants.py
+++ b/lbry/dht/constants.py
@ -0,0 +1,40 @@
 import hashlib
 import os
 HASH_CLASS = hashlib.sha384  # pylint: disable=invalid-name
 HASH_LENGTH = HASH_CLASS().digest_size
 HASH_BITS = HASH_LENGTH * 8
 ALPHA = 5
 K = 8
 SPLIT_BUCKETS_UNDER_INDEX = 1
 REPLACEMENT_CACHE_SIZE = 8
 RPC_TIMEOUT = 5.0
 RPC_ATTEMPTS = 5
 RPC_ATTEMPTS_PRUNING_WINDOW = 600
 ITERATIVE_LOOKUP_DELAY = RPC_TIMEOUT / 2.0  # TODO: use config val / 2 if rpc timeout is provided
 REFRESH_INTERVAL = 3600  # 1 hour
 REPLICATE_INTERVAL = REFRESH_INTERVAL
 DATA_EXPIRATION = 86400  # 24 hours
 TOKEN_SECRET_REFRESH_INTERVAL = 300  # 5 minutes
 MAYBE_PING_DELAY = 300  # 5 minutes
 CHECK_REFRESH_INTERVAL = REFRESH_INTERVAL / 5
 RPC_ID_LENGTH = 20
 PROTOCOL_VERSION = 1
 MSG_SIZE_LIMIT = 1400
 def digest(data: bytes) -> bytes:
    h = HASH_CLASS()
    h.update(data)
    return h.digest()
 def generate_id(num=None) -> bytes:
    if num is not None:
        return digest(str(num).encode())
    else:
        return digest(os.urandom(32))
 def generate_rpc_id(num=None) -> bytes:
    return generate_id(num)[:RPC_ID_LENGTH]
--- a/lbry/lbry/dht/error.py
+++ b/lbry/lbry/dht/error.py
--- a/lbry/lbry/dht/node.py
+++ b/lbry/lbry/dht/node.py
@ -1,9 +1,11 @@
 import logging
 import asyncio
 import typing
 import binascii
 import socket
-from lbry.utils import resolve_host
+
 from prometheus_client import Gauge
 from lbry.utils import aclosing, resolve_host
 from lbry.dht import constants
 from lbry.dht.peer import make_kademlia_peer
 from lbry.dht.protocol.distance import Distance
@ -18,20 +20,32 @@ log = logging.getLogger(__name__)
 class Node:
    storing_peers_metric = Gauge(
        "storing_peers", "Number of peers storing blobs announced to this node", namespace="dht_node",
        labelnames=("scope",),
    )
    stored_blob_with_x_bytes_colliding = Gauge(
        "stored_blobs_x_bytes_colliding", "Number of blobs with at least X bytes colliding with this node id prefix",
        namespace="dht_node", labelnames=("amount",)
    )
    def __init__(self, loop: asyncio.AbstractEventLoop, peer_manager: 'PeerManager', node_id: bytes, udp_port: int,
-                 internal_udp_port: int, peer_port: int, external_ip: str, rpc_timeout: float = constants.rpc_timeout,
+                 internal_udp_port: int, peer_port: int, external_ip: str, rpc_timeout: float = constants.RPC_TIMEOUT,
-                 split_buckets_under_index: int = constants.split_buckets_under_index,
+                 split_buckets_under_index: int = constants.SPLIT_BUCKETS_UNDER_INDEX, is_bootstrap_node: bool = False,
                 storage: typing.Optional['SQLiteStorage'] = None):
        self.loop = loop
        self.internal_udp_port = internal_udp_port
        self.protocol = KademliaProtocol(loop, peer_manager, node_id, external_ip, udp_port, peer_port, rpc_timeout,
-                                         split_buckets_under_index)
+                                         split_buckets_under_index, is_bootstrap_node)
        self.listening_port: asyncio.DatagramTransport = None
-        self.joined = asyncio.Event(loop=self.loop)
+        self.joined = asyncio.Event()
        self._join_task: asyncio.Task = None
        self._refresh_task: asyncio.Task = None
        self._storage = storage
    @property
    def stored_blob_hashes(self):
        return self.protocol.data_store.keys()
    async def refresh_node(self, force_once=False):
        while True:
            # remove peers with expired blob announcements from the datastore
@ -41,17 +55,21 @@ class Node:
            # add all peers in the routing table
            total_peers.extend(self.protocol.routing_table.get_peers())
            # add all the peers who have announced blobs to us
-            total_peers.extend(self.protocol.data_store.get_storing_contacts())
+            storing_peers = self.protocol.data_store.get_storing_contacts()
            self.storing_peers_metric.labels("global").set(len(storing_peers))
            total_peers.extend(storing_peers)
            counts = {0: 0, 1: 0, 2: 0}
            node_id = self.protocol.node_id
            for blob_hash in self.protocol.data_store.keys():
                bytes_colliding = 0 if blob_hash[0] != node_id[0] else 2 if blob_hash[1] == node_id[1] else 1
                counts[bytes_colliding] += 1
            self.stored_blob_with_x_bytes_colliding.labels(amount=0).set(counts[0])
            self.stored_blob_with_x_bytes_colliding.labels(amount=1).set(counts[1])
            self.stored_blob_with_x_bytes_colliding.labels(amount=2).set(counts[2])
            # get ids falling in the midpoint of each bucket that hasn't been recently updated
            node_ids = self.protocol.routing_table.get_refresh_list(0, True)
            # if we have 3 or fewer populated buckets get two random ids in the range of each to try and
            # populate/split the buckets further
            buckets_with_contacts = self.protocol.routing_table.buckets_with_contacts()
            if buckets_with_contacts <= 3:
                for i in range(buckets_with_contacts):
                    node_ids.append(self.protocol.routing_table.random_id_in_bucket_range(i))
                    node_ids.append(self.protocol.routing_table.random_id_in_bucket_range(i))
            if self.protocol.routing_table.get_peers():
                # if we have node ids to look up, perform the iterative search until we have k results
@ -61,8 +79,8 @@ class Node:
            else:
                if force_once:
                    break
-                fut = asyncio.Future(loop=self.loop)
+                fut = asyncio.Future()
-                self.loop.call_later(constants.refresh_interval // 4, fut.set_result, None)
+                self.loop.call_later(constants.REFRESH_INTERVAL // 4, fut.set_result, None)
                await fut
                continue
@ -75,13 +93,13 @@ class Node:
            if force_once:
                break
-            fut = asyncio.Future(loop=self.loop)
+            fut = asyncio.Future()
-            self.loop.call_later(constants.refresh_interval, fut.set_result, None)
+            self.loop.call_later(constants.REFRESH_INTERVAL, fut.set_result, None)
            await fut
    async def announce_blob(self, blob_hash: str) -> typing.List[bytes]:
-        hash_value = binascii.unhexlify(blob_hash.encode())
+        hash_value = bytes.fromhex(blob_hash)
-        assert len(hash_value) == constants.hash_length
+        assert len(hash_value) == constants.HASH_LENGTH
        peers = await self.peer_search(hash_value)
        if not self.protocol.external_ip:
@ -90,12 +108,14 @@ class Node:
        for peer in peers:
            log.debug("store to %s %s %s", peer.address, peer.udp_port, peer.tcp_port)
        stored_to_tup = await asyncio.gather(
-            *(self.protocol.store_to_peer(hash_value, peer) for peer in peers), loop=self.loop
+            *(self.protocol.store_to_peer(hash_value, peer) for peer in peers)
        )
        stored_to = [node_id for node_id, contacted in stored_to_tup if contacted]
        if stored_to:
-            log.debug("Stored %s to %i of %i attempted peers", binascii.hexlify(hash_value).decode()[:8],
+            log.debug(
-                     len(stored_to), len(peers))
+                "Stored %s to %i of %i attempted peers", hash_value.hex()[:8],
                len(stored_to), len(peers)
            )
        else:
            log.debug("Failed announcing %s, stored to 0 peers", blob_hash[:8])
        return stored_to
@ -162,39 +182,36 @@ class Node:
                            for address, udp_port in known_node_urls or []
                        ]))
                    except socket.gaierror:
-                        await asyncio.sleep(30, loop=self.loop)
+                        await asyncio.sleep(30)
                        continue
                self.protocol.peer_manager.reset()
                self.protocol.ping_queue.enqueue_maybe_ping(*seed_peers, delay=0.0)
                await self.peer_search(self.protocol.node_id, shortlist=seed_peers, count=32)
-            await asyncio.sleep(1, loop=self.loop)
+            await asyncio.sleep(1)
    def start(self, interface: str, known_node_urls: typing.Optional[typing.List[typing.Tuple[str, int]]] = None):
        self._join_task = self.loop.create_task(self.join_network(interface, known_node_urls))
    def get_iterative_node_finder(self, key: bytes, shortlist: typing.Optional[typing.List['KademliaPeer']] = None,
-                                  bottom_out_limit: int = constants.bottom_out_limit,
+                                  max_results: int = constants.K) -> IterativeNodeFinder:
-                                  max_results: int = constants.k) -> IterativeNodeFinder:
+        shortlist = shortlist or self.protocol.routing_table.find_close_peers(key)
-
+        return IterativeNodeFinder(self.loop, self.protocol, key, max_results, shortlist)
        return IterativeNodeFinder(self.loop, self.protocol.peer_manager, self.protocol.routing_table, self.protocol,
                                   key, bottom_out_limit, max_results, None, shortlist)
    def get_iterative_value_finder(self, key: bytes, shortlist: typing.Optional[typing.List['KademliaPeer']] = None,
                                   bottom_out_limit: int = 40,
                                   max_results: int = -1) -> IterativeValueFinder:
        shortlist = shortlist or self.protocol.routing_table.find_close_peers(key)
        return IterativeValueFinder(self.loop, self.protocol, key, max_results, shortlist)
-        return IterativeValueFinder(self.loop, self.protocol.peer_manager, self.protocol.routing_table, self.protocol,
+    async def peer_search(self, node_id: bytes, count=constants.K, max_results=constants.K * 2,
-                                    key, bottom_out_limit, max_results, None, shortlist)
+                          shortlist: typing.Optional[typing.List['KademliaPeer']] = None
    async def peer_search(self, node_id: bytes, count=constants.k, max_results=constants.k*2,
                          bottom_out_limit=20, shortlist: typing.Optional[typing.List['KademliaPeer']] = None
                          ) -> typing.List['KademliaPeer']:
        peers = []
-        async for iteration_peers in self.get_iterative_node_finder(
+        async with aclosing(self.get_iterative_node_finder(
-                node_id, shortlist=shortlist, bottom_out_limit=bottom_out_limit, max_results=max_results):
+                node_id, shortlist=shortlist, max_results=max_results)) as node_finder:
-            peers.extend(iteration_peers)
+            async for iteration_peers in node_finder:
                peers.extend(iteration_peers)
        distance = Distance(node_id)
        peers.sort(key=lambda peer: distance(peer.node_id))
        return peers[:count]
@ -220,39 +237,46 @@ class Node:
        # prioritize peers who reply to a dht ping first
        # this minimizes attempting to make tcp connections that won't work later to dead or unreachable peers
-
+        async with aclosing(self.get_iterative_value_finder(bytes.fromhex(blob_hash))) as value_finder:
-        async for results in self.get_iterative_value_finder(binascii.unhexlify(blob_hash.encode())):
+            async for results in value_finder:
-            to_put = []
+                to_put = []
-            for peer in results:
+                for peer in results:
-                if peer.address == self.protocol.external_ip and self.protocol.peer_port == peer.tcp_port:
+                    if peer.address == self.protocol.external_ip and self.protocol.peer_port == peer.tcp_port:
-                    continue
+                        continue
-                is_good = self.protocol.peer_manager.peer_is_good(peer)
+                    is_good = self.protocol.peer_manager.peer_is_good(peer)
-                if is_good:
+                    if is_good:
-                    # the peer has replied recently over UDP, it can probably be reached on the TCP port
+                        # the peer has replied recently over UDP, it can probably be reached on the TCP port
-                    to_put.append(peer)
+                        to_put.append(peer)
-                elif is_good is None:
+                    elif is_good is None:
-                    if not peer.udp_port:
+                        if not peer.udp_port:
-                        # TODO: use the same port for TCP and UDP
+                            # TODO: use the same port for TCP and UDP
-                        # the udp port must be guessed
+                            # the udp port must be guessed
-                        # default to the ports being the same. if the TCP port appears to be <=0.48.0 default,
+                            # default to the ports being the same. if the TCP port appears to be <=0.48.0 default,
-                        # including on a network with several nodes, then assume the udp port is proportionately
+                            # including on a network with several nodes, then assume the udp port is proportionately
-                        # based on a starting port of 4444
+                            # based on a starting port of 4444
-                        udp_port_to_try = peer.tcp_port
+                            udp_port_to_try = peer.tcp_port
-                        if 3400 > peer.tcp_port > 3332:
+                            if 3400 > peer.tcp_port > 3332:
-                            udp_port_to_try = (peer.tcp_port - 3333) + 4444
+                                udp_port_to_try = (peer.tcp_port - 3333) + 4444
-                        self.loop.create_task(put_into_result_queue_after_pong(
+                            self.loop.create_task(put_into_result_queue_after_pong(
-                            make_kademlia_peer(peer.node_id, peer.address, udp_port_to_try, peer.tcp_port)
+                                make_kademlia_peer(peer.node_id, peer.address, udp_port_to_try, peer.tcp_port)
-                        ))
+                            ))
                        else:
                            self.loop.create_task(put_into_result_queue_after_pong(peer))
                    else:
-                        self.loop.create_task(put_into_result_queue_after_pong(peer))
+                        # the peer is known to be bad/unreachable, skip trying to connect to it over TCP
-                else:
+                        log.debug("skip bad peer %s:%i for %s", peer.address, peer.tcp_port, blob_hash)
-                    # the peer is known to be bad/unreachable, skip trying to connect to it over TCP
+                if to_put:
-                    log.debug("skip bad peer %s:%i for %s", peer.address, peer.tcp_port, blob_hash)
+                    result_queue.put_nowait(to_put)
            if to_put:
                result_queue.put_nowait(to_put)
    def accumulate_peers(self, search_queue: asyncio.Queue,
-                         peer_queue: typing.Optional[asyncio.Queue] = None) -> typing.Tuple[
+                         peer_queue: typing.Optional[asyncio.Queue] = None
-                         asyncio.Queue, asyncio.Task]:
+                         ) -> typing.Tuple[asyncio.Queue, asyncio.Task]:
-        q = peer_queue or asyncio.Queue(loop=self.loop)
+        queue = peer_queue or asyncio.Queue()
-        return q, self.loop.create_task(self._accumulate_peers_for_value(search_queue, q))
+        return queue, self.loop.create_task(self._accumulate_peers_for_value(search_queue, queue))
 async def get_kademlia_peers_from_hosts(peer_list: typing.List[typing.Tuple[str, int]]) -> typing.List['KademliaPeer']:
    peer_address_list = [(await resolve_host(url, port, proto='tcp'), port) for url, port in peer_list]
    kademlia_peer_list = [make_kademlia_peer(None, address, None, tcp_port=port, allow_localhost=True)
                          for address, port in peer_address_list]
    return kademlia_peer_list
--- a/lbry/lbry/dht/peer.py
+++ b/lbry/lbry/dht/peer.py
@ -1,18 +1,21 @@
 import typing
 import asyncio
 import logging
 import ipaddress
 from binascii import hexlify
 from dataclasses import dataclass, field
 from functools import lru_cache
 from prometheus_client import Gauge
 from lbry.utils import is_valid_public_ipv4 as _is_valid_public_ipv4, LRUCache
 from lbry.dht import constants
 from lbry.dht.serialization.datagram import make_compact_address, make_compact_ip, decode_compact_address
 ALLOW_LOCALHOST = False
 CACHE_SIZE = 16384
 log = logging.getLogger(__name__)
-@lru_cache(1024)
+@lru_cache(CACHE_SIZE)
 def make_kademlia_peer(node_id: typing.Optional[bytes], address: typing.Optional[str],
                       udp_port: typing.Optional[int] = None,
                       tcp_port: typing.Optional[int] = None,
@ -20,40 +23,32 @@ def make_kademlia_peer(node_id: typing.Optional[bytes], address: typing.Optional
    return KademliaPeer(address, node_id, udp_port, tcp_port=tcp_port, allow_localhost=allow_localhost)
 # the ipaddress module does not show these subnets as reserved
 carrier_grade_NAT_subnet = ipaddress.ip_network('100.64.0.0/10')
 ip4_to_6_relay_subnet = ipaddress.ip_network('192.88.99.0/24')
 ALLOW_LOCALHOST = False
 def is_valid_public_ipv4(address, allow_localhost: bool = False):
    allow_localhost = bool(allow_localhost or ALLOW_LOCALHOST)
-    try:
+    return _is_valid_public_ipv4(address, allow_localhost)
        parsed_ip = ipaddress.ip_address(address)
        if parsed_ip.is_loopback and allow_localhost:
            return True
        return not any((parsed_ip.version != 4, parsed_ip.is_unspecified, parsed_ip.is_link_local,
                        parsed_ip.is_loopback, parsed_ip.is_multicast, parsed_ip.is_reserved, parsed_ip.is_private,
                        parsed_ip.is_reserved,
                        carrier_grade_NAT_subnet.supernet_of(ipaddress.ip_network(f"{address}/32")),
                        ip4_to_6_relay_subnet.supernet_of(ipaddress.ip_network(f"{address}/32"))))
    except ipaddress.AddressValueError:
        return False
 class PeerManager:
    peer_manager_keys_metric = Gauge(
        "peer_manager_keys", "Number of keys tracked by PeerManager dicts (sum)", namespace="dht_node",
        labelnames=("scope",)
    )
    def __init__(self, loop: asyncio.AbstractEventLoop):
        self._loop = loop
        self._rpc_failures: typing.Dict[
            typing.Tuple[str, int], typing.Tuple[typing.Optional[float], typing.Optional[float]]
-        ] = {}
+        ] = LRUCache(CACHE_SIZE)
-        self._last_replied: typing.Dict[typing.Tuple[str, int], float] = {}
+        self._last_replied: typing.Dict[typing.Tuple[str, int], float] = LRUCache(CACHE_SIZE)
-        self._last_sent: typing.Dict[typing.Tuple[str, int], float] = {}
+        self._last_sent: typing.Dict[typing.Tuple[str, int], float] = LRUCache(CACHE_SIZE)
-        self._last_requested: typing.Dict[typing.Tuple[str, int], float] = {}
+        self._last_requested: typing.Dict[typing.Tuple[str, int], float] = LRUCache(CACHE_SIZE)
-        self._node_id_mapping: typing.Dict[typing.Tuple[str, int], bytes] = {}
+        self._node_id_mapping: typing.Dict[typing.Tuple[str, int], bytes] = LRUCache(CACHE_SIZE)
-        self._node_id_reverse_mapping: typing.Dict[bytes, typing.Tuple[str, int]] = {}
+        self._node_id_reverse_mapping: typing.Dict[bytes, typing.Tuple[str, int]] = LRUCache(CACHE_SIZE)
-        self._node_tokens: typing.Dict[bytes, (float, bytes)] = {}
+        self._node_tokens: typing.Dict[bytes, (float, bytes)] = LRUCache(CACHE_SIZE)
    def count_cache_keys(self):
        return len(self._rpc_failures) + len(self._last_replied) + len(self._last_sent) + len(
            self._last_requested) + len(self._node_id_mapping) + len(self._node_id_reverse_mapping) + len(
            self._node_tokens)
    def reset(self):
        for statistic in (self._rpc_failures, self._last_replied, self._last_sent, self._last_requested):
@ -85,7 +80,7 @@ class PeerManager:
    def get_node_token(self, node_id: bytes) -> typing.Optional[bytes]:
        ts, token = self._node_tokens.get(node_id, (0, None))
-        if ts and ts > self._loop.time() - constants.token_secret_refresh_interval:
+        if ts and ts > self._loop.time() - constants.TOKEN_SECRET_REFRESH_INTERVAL:
            return token
    def get_last_replied(self, address: str, udp_port: int) -> typing.Optional[float]:
@ -103,28 +98,32 @@ class PeerManager:
            self._node_id_mapping.pop(self._node_id_reverse_mapping.pop(node_id))
        self._node_id_mapping[(address, udp_port)] = node_id
        self._node_id_reverse_mapping[node_id] = (address, udp_port)
        self.peer_manager_keys_metric.labels("global").set(self.count_cache_keys())
    def get_node_id_for_endpoint(self, address, port):
        return self._node_id_mapping.get((address, port))
    def prune(self):  # TODO: periodically call this
        now = self._loop.time()
        to_pop = []
        for (address, udp_port), (_, last_failure) in self._rpc_failures.items():
-            if last_failure and last_failure < now - constants.rpc_attempts_pruning_window:
+            if last_failure and last_failure < now - constants.RPC_ATTEMPTS_PRUNING_WINDOW:
                to_pop.append((address, udp_port))
        while to_pop:
            del self._rpc_failures[to_pop.pop()]
        to_pop = []
-        for node_id, (age, token) in self._node_tokens.items():
+        for node_id, (age, token) in self._node_tokens.items():  # pylint: disable=unused-variable
-            if age < now - constants.token_secret_refresh_interval:
+            if age < now - constants.TOKEN_SECRET_REFRESH_INTERVAL:
                to_pop.append(node_id)
        while to_pop:
            del self._node_tokens[to_pop.pop()]
-    def contact_triple_is_good(self, node_id: bytes, address: str, udp_port: int):
+    def contact_triple_is_good(self, node_id: bytes, address: str, udp_port: int):  # pylint: disable=too-many-return-statements
        """
        :return: False if peer is bad, None if peer is unknown, or True if peer is good
        """
-        delay = self._loop.time() - constants.check_refresh_interval
+        delay = self._loop.time() - constants.CHECK_REFRESH_INTERVAL
        # fixme: find a way to re-enable that without breaking other parts
        # if node_id not in self._node_id_reverse_mapping or (address, udp_port) not in self._node_id_mapping:
@ -154,9 +153,10 @@ class PeerManager:
    def peer_is_good(self, peer: 'KademliaPeer'):
        return self.contact_triple_is_good(peer.node_id, peer.address, peer.udp_port)
-    def decode_tcp_peer_from_compact_address(self, compact_address: bytes) -> 'KademliaPeer':
+
-        node_id, address, tcp_port = decode_compact_address(compact_address)
+def decode_tcp_peer_from_compact_address(compact_address: bytes) -> 'KademliaPeer':  # pylint: disable=no-self-use
-        return make_kademlia_peer(node_id, address, udp_port=None, tcp_port=tcp_port)
+    node_id, address, tcp_port = decode_compact_address(compact_address)
    return make_kademlia_peer(node_id, address, udp_port=None, tcp_port=tcp_port)
@dataclass(unsafe_hash=True)
@ -170,12 +170,12 @@ class KademliaPeer:
    def __post_init__(self):
        if self._node_id is not None:
-            if not len(self._node_id) == constants.hash_length:
+            if not len(self._node_id) == constants.HASH_LENGTH:
-                raise ValueError("invalid node_id: {}".format(hexlify(self._node_id).decode()))
+                raise ValueError("invalid node_id: {}".format(self._node_id.hex()))
-        if self.udp_port is not None and not 1 <= self.udp_port <= 65535:
+        if self.udp_port is not None and not 1024 <= self.udp_port <= 65535:
-            raise ValueError("invalid udp port")
+            raise ValueError(f"invalid udp port: {self.address}:{self.udp_port}")
-        if self.tcp_port is not None and not 1 <= self.tcp_port <= 65535:
+        if self.tcp_port is not None and not 1024 <= self.tcp_port <= 65535:
-            raise ValueError("invalid tcp port")
+            raise ValueError(f"invalid tcp port: {self.address}:{self.tcp_port}")
        if not is_valid_public_ipv4(self.address, self.allow_localhost):
            raise ValueError(f"invalid ip address: '{self.address}'")
@ -194,3 +194,6 @@ class KademliaPeer:
    def compact_ip(self):
        return make_compact_ip(self.address)
    def __str__(self):
        return f"{self.__class__.__name__}({self.node_id.hex()[:8]}@{self.address}:{self.udp_port}-{self.tcp_port})"
--- a/lbry/lbry/dht/serialization/init.py
+++ b/lbry/lbry/dht/serialization/init.py
--- a/lbry/lbry/dht/protocol/data_store.py
+++ b/lbry/lbry/dht/protocol/data_store.py
@ -16,13 +16,19 @@ class DictDataStore:
        self._peer_manager = peer_manager
        self.completed_blobs: typing.Set[str] = set()
    def keys(self):
        return self._data_store.keys()
    def __len__(self):
        return self._data_store.__len__()
    def removed_expired_peers(self):
        now = self.loop.time()
        keys = list(self._data_store.keys())
        for key in keys:
            to_remove = []
            for (peer, ts) in self._data_store[key]:
-                if ts + constants.data_expiration < now or self._peer_manager.peer_is_good(peer) is False:
+                if ts + constants.DATA_EXPIRATION < now or self._peer_manager.peer_is_good(peer) is False:
                    to_remove.append((peer, ts))
            for item in to_remove:
                self._data_store[key].remove(item)
@ -43,7 +49,7 @@ class DictDataStore:
        """
        now = self.loop.time()
        for (peer, ts) in self._data_store.get(key, []):
-            if ts + constants.data_expiration > now:
+            if ts + constants.DATA_EXPIRATION > now:
                yield peer
    def has_peers_for_blob(self, key: bytes) -> bool:
@ -53,7 +59,7 @@ class DictDataStore:
        now = self.loop.time()
        if key in self._data_store:
            current = list(filter(lambda x: x[0] == contact, self._data_store[key]))
-            if len(current):
+            if len(current) > 0:
                self._data_store[key][self._data_store[key].index(current[0])] = contact, now
            else:
                self._data_store[key].append((contact, now))
@ -65,6 +71,6 @@ class DictDataStore:
    def get_storing_contacts(self) -> typing.List['KademliaPeer']:
        peers = set()
-        for key, stored in self._data_store.items():
+        for _, stored in self._data_store.items():
            peers.update(set(map(lambda tup: tup[0], stored)))
        return list(peers)
--- a/lbry/lbry/dht/protocol/distance.py
+++ b/lbry/lbry/dht/protocol/distance.py
@ -9,17 +9,17 @@ class Distance:
    """
    def __init__(self, key: bytes):
-        if len(key) != constants.hash_length:
+        if len(key) != constants.HASH_LENGTH:
            raise ValueError(f"invalid key length: {len(key)}")
        self.key = key
        self.val_key_one = int.from_bytes(key, 'big')
    def __call__(self, key_two: bytes) -> int:
-        if len(key_two) != constants.hash_length:
+        if len(key_two) != constants.HASH_LENGTH:
            raise ValueError(f"invalid length of key to compare: {len(key_two)}")
        val_key_two = int.from_bytes(key_two, 'big')
        return self.val_key_one ^ val_key_two
-    def is_closer(self, a: bytes, b: bytes) -> bool:
+    def is_closer(self, key_a: bytes, key_b: bytes) -> bool:
-        """Returns true is `a` is closer to `key` than `b` is"""
+        """Returns true is `key_a` is closer to `key` than `key_b` is"""
-        return self(a) < self(b)
+        return self(key_a) < self(key_b)
--- a/lbry/lbry/dht/protocol/iterative_find.py
+++ b/lbry/lbry/dht/protocol/iterative_find.py
@ -1,18 +1,17 @@
 import asyncio
 from binascii import hexlify
 from itertools import chain
-from collections import defaultdict
+from collections import defaultdict, OrderedDict
 from collections.abc import AsyncIterator
 import typing
 import logging
 from typing import TYPE_CHECKING
 from lbry.dht import constants
 from lbry.dht.error import RemoteException, TransportNotConnected
 from lbry.dht.protocol.distance import Distance
-from lbry.dht.peer import make_kademlia_peer
+from lbry.dht.peer import make_kademlia_peer, decode_tcp_peer_from_compact_address
 from lbry.dht.serialization.datagram import PAGE_KEY
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
    from lbry.dht.protocol.routing_table import TreeRoutingTable
    from lbry.dht.protocol.protocol import KademliaProtocol
    from lbry.dht.peer import PeerManager, KademliaPeer
@ -27,6 +26,15 @@ class FindResponse:
    def get_close_triples(self) -> typing.List[typing.Tuple[bytes, str, int]]:
        raise NotImplementedError()
    def get_close_kademlia_peers(self, peer_info) -> typing.Generator[typing.Iterator['KademliaPeer'], None, None]:
        for contact_triple in self.get_close_triples():
            node_id, address, udp_port = contact_triple
            try:
                yield make_kademlia_peer(node_id, address, udp_port)
            except ValueError:
                log.warning("misbehaving peer %s:%i returned peer with reserved ip %s:%i", peer_info.address,
                            peer_info.udp_port, address, udp_port)
 class FindNodeResponse(FindResponse):
    def __init__(self, key: bytes, close_triples: typing.List[typing.Tuple[bytes, str, int]]):
@ -57,57 +65,33 @@ class FindValueResponse(FindResponse):
        return [(node_id, address.decode(), port) for node_id, address, port in self.close_triples]
-def get_shortlist(routing_table: 'TreeRoutingTable', key: bytes,
+class IterativeFinder(AsyncIterator):
-                  shortlist: typing.Optional[typing.List['KademliaPeer']]) -> typing.List['KademliaPeer']:
+    def __init__(self, loop: asyncio.AbstractEventLoop,
-    """
+                 protocol: 'KademliaProtocol', key: bytes,
-    If not provided, initialize the shortlist of peers to probe to the (up to) k closest peers in the routing table
+                 max_results: typing.Optional[int] = constants.K,
    :param routing_table: a TreeRoutingTable
    :param key: a 48 byte hash
    :param shortlist: optional manually provided shortlist, this is done during bootstrapping when there are no
                      peers in the routing table. During bootstrap the shortlist is set to be the seed nodes.
    """
    if len(key) != constants.hash_length:
        raise ValueError("invalid key length: %i" % len(key))
    return shortlist or routing_table.find_close_peers(key)
 class IterativeFinder:
    def __init__(self, loop: asyncio.AbstractEventLoop, peer_manager: 'PeerManager',
                 routing_table: 'TreeRoutingTable', protocol: 'KademliaProtocol', key: bytes,
                 bottom_out_limit: typing.Optional[int] = 2, max_results: typing.Optional[int] = constants.k,
                 exclude: typing.Optional[typing.List[typing.Tuple[str, int]]] = None,
                 shortlist: typing.Optional[typing.List['KademliaPeer']] = None):
-        if len(key) != constants.hash_length:
+        if len(key) != constants.HASH_LENGTH:
            raise ValueError("invalid key length: %i" % len(key))
        self.loop = loop
-        self.peer_manager = peer_manager
+        self.peer_manager = protocol.peer_manager
        self.routing_table = routing_table
        self.protocol = protocol
        self.key = key
-        self.bottom_out_limit = bottom_out_limit
+        self.max_results = max(constants.K, max_results)
        self.max_results = max_results
        self.exclude = exclude or []
-        self.active: typing.Set['KademliaPeer'] = set()
+        self.active: typing.Dict['KademliaPeer', int] = OrderedDict()  # peer: distance, sorted
        self.contacted: typing.Set['KademliaPeer'] = set()
        self.distance = Distance(key)
-        self.closest_peer: typing.Optional['KademliaPeer'] = None
+        self.iteration_queue = asyncio.Queue()
        self.prev_closest_peer: typing.Optional['KademliaPeer'] = None
-        self.iteration_queue = asyncio.Queue(loop=self.loop)
+        self.running_probes: typing.Dict['KademliaPeer', asyncio.Task] = {}
        self.running_probes: typing.Set[asyncio.Task] = set()
        self.iteration_count = 0
        self.bottom_out_count = 0
        self.running = False
        self.tasks: typing.List[asyncio.Task] = []
-        self.delayed_calls: typing.List[asyncio.Handle] = []
+        for peer in shortlist:
        for peer in get_shortlist(routing_table, key, shortlist):
            if peer.node_id:
-                self._add_active(peer)
+                self._add_active(peer, force=True)
            else:
                # seed nodes
                self._schedule_probe(peer)
@ -132,73 +116,86 @@ class IterativeFinder:
        """
        raise NotImplementedError()
-    def get_initial_result(self) -> typing.List['KademliaPeer']:
+    def get_initial_result(self) -> typing.List['KademliaPeer']:  #pylint: disable=no-self-use
        """
        Get an initial or cached result to be put into the Queue. Used for findValue requests where the blob
        has peers in the local data store of blobs announced to us
        """
        return []
-    def _is_closer(self, peer: 'KademliaPeer') -> bool:
+    def _add_active(self, peer, force=False):
-        return not self.closest_peer or self.distance.is_closer(peer.node_id, self.closest_peer.node_id)
+        if not force and self.peer_manager.peer_is_good(peer) is False:
-
+            return
-    def _add_active(self, peer):
+        if peer in self.contacted:
            return
        if peer not in self.active and peer.node_id and peer.node_id != self.protocol.node_id:
-            self.active.add(peer)
+            self.active[peer] = self.distance(peer.node_id)
-            if self._is_closer(peer):
+            self.active = OrderedDict(sorted(self.active.items(), key=lambda item: item[1]))
                self.prev_closest_peer = self.closest_peer
                self.closest_peer = peer
    async def _handle_probe_result(self, peer: 'KademliaPeer', response: FindResponse):
        self._add_active(peer)
-        for contact_triple in response.get_close_triples():
+        for new_peer in response.get_close_kademlia_peers(peer):
-            node_id, address, udp_port = contact_triple
+            self._add_active(new_peer)
            try:
                self._add_active(make_kademlia_peer(node_id, address, udp_port))
            except ValueError:
                log.warning("misbehaving peer %s:%i returned peer with reserved ip %s:%i", peer.address,
                            peer.udp_port, address, udp_port)
        self.check_result_ready(response)
        self._log_state(reason="check result")
    def _reset_closest(self, peer):
        if peer in self.active:
            del self.active[peer]
    async def _send_probe(self, peer: 'KademliaPeer'):
        try:
            response = await self.send_probe(peer)
        except asyncio.TimeoutError:
-            self.active.discard(peer)
+            self._reset_closest(peer)
            return
        except asyncio.CancelledError:
            log.debug("%s[%x] cancelled probe",
                      type(self).__name__, id(self))
            raise
        except ValueError as err:
            log.warning(str(err))
-            self.active.discard(peer)
+            self._reset_closest(peer)
            return
        except TransportNotConnected:
-            return self.aclose()
+            await self._aclose(reason="not connected")
            return
        except RemoteException:
            self._reset_closest(peer)
            return
        return await self._handle_probe_result(peer, response)
-    async def _search_round(self):
+    def _search_round(self):
        """
        Send up to constants.alpha (5) probes to closest active peers
        """
        added = 0
-        to_probe = list(self.active - self.contacted)
+        for index, peer in enumerate(self.active.keys()):
-        to_probe.sort(key=lambda peer: self.distance(self.key))
+            if index == 0:
-        for peer in to_probe:
+                log.debug("%s[%x] closest to probe: %s",
-            if added >= constants.alpha:
+                          type(self).__name__, id(self),
                          peer.node_id.hex()[:8])
            if peer in self.contacted:
                continue
            if len(self.running_probes) >= constants.ALPHA:
                break
            if index > (constants.K + len(self.running_probes)):
                break
            origin_address = (peer.address, peer.udp_port)
            if origin_address in self.exclude:
                continue
            if peer.node_id == self.protocol.node_id:
                continue
            if origin_address == (self.protocol.external_ip, self.protocol.udp_port):
                continue
            self._schedule_probe(peer)
            added += 1
-        log.debug("running %d probes", len(self.running_probes))
+        log.debug("%s[%x] running %d probes for key %s",
                  type(self).__name__, id(self),
                  len(self.running_probes), self.key.hex()[:8])
        if not added and not self.running_probes:
-            log.debug("search for %s exhausted", hexlify(self.key)[:8])
+            log.debug("%s[%x] search for %s exhausted",
                      type(self).__name__, id(self),
                      self.key.hex()[:8])
            self.search_exhausted()
    def _schedule_probe(self, peer: 'KademliaPeer'):
@ -207,33 +204,24 @@ class IterativeFinder:
        t = self.loop.create_task(self._send_probe(peer))
        def callback(_):
-            self.running_probes.difference_update({
+            self.running_probes.pop(peer, None)
-                probe for probe in self.running_probes if probe.done() or probe == t
+            if self.running:
-            })
+                self._search_round()
            if not self.running_probes:
                self.tasks.append(self.loop.create_task(self._search_task(0.0)))
        t.add_done_callback(callback)
-        self.running_probes.add(t)
+        self.running_probes[peer] = t
-    async def _search_task(self, delay: typing.Optional[float] = constants.iterative_lookup_delay):
+    def _log_state(self, reason="?"):
-        try:
+        log.debug("%s[%x] [%s] %s: %i active nodes %i contacted %i produced %i queued",
-            if self.running:
+                  type(self).__name__, id(self), self.key.hex()[:8],
-                await self._search_round()
+                  reason, len(self.active), len(self.contacted),
-            if self.running:
+                  self.iteration_count, self.iteration_queue.qsize())
                self.delayed_calls.append(self.loop.call_later(delay, self._search))
        except (asyncio.CancelledError, StopAsyncIteration, TransportNotConnected):
            if self.running:
                self.loop.call_soon(self.aclose)
    def _search(self):
        self.tasks.append(self.loop.create_task(self._search_task()))
    def __aiter__(self):
        if self.running:
            raise Exception("already running")
        self.running = True
-        self._search()
+        self.loop.call_soon(self._search_round)
        return self
    async def __anext__(self) -> typing.List['KademliaPeer']:
@ -246,47 +234,57 @@ class IterativeFinder:
                raise StopAsyncIteration
            self.iteration_count += 1
            return result
-        except (asyncio.CancelledError, StopAsyncIteration):
+        except asyncio.CancelledError:
-            self.loop.call_soon(self.aclose)
+            await self._aclose(reason="cancelled")
            raise
        except StopAsyncIteration:
            await self._aclose(reason="no more results")
            raise
-    def aclose(self):
+    async def _aclose(self, reason="?"):
        log.debug("%s[%x] [%s] shutdown because %s: %i active nodes %i contacted %i produced %i queued",
                  type(self).__name__, id(self), self.key.hex()[:8],
                  reason, len(self.active), len(self.contacted),
                  self.iteration_count, self.iteration_queue.qsize())
        self.running = False
        self.iteration_queue.put_nowait(None)
-        for task in chain(self.tasks, self.running_probes, self.delayed_calls):
+        for task in chain(self.tasks, self.running_probes.values()):
            task.cancel()
        self.tasks.clear()
        self.running_probes.clear()
        self.delayed_calls.clear()
    async def aclose(self):
        if self.running:
            await self._aclose(reason="aclose")
        log.debug("%s[%x] [%s] async close completed",
                  type(self).__name__, id(self), self.key.hex()[:8])
 class IterativeNodeFinder(IterativeFinder):
-    def __init__(self, loop: asyncio.AbstractEventLoop, peer_manager: 'PeerManager',
+    def __init__(self, loop: asyncio.AbstractEventLoop,
-                 routing_table: 'TreeRoutingTable', protocol: 'KademliaProtocol', key: bytes,
+                 protocol: 'KademliaProtocol', key: bytes,
-                 bottom_out_limit: typing.Optional[int] = 2, max_results: typing.Optional[int] = constants.k,
+                 max_results: typing.Optional[int] = constants.K,
                 exclude: typing.Optional[typing.List[typing.Tuple[str, int]]] = None,
                 shortlist: typing.Optional[typing.List['KademliaPeer']] = None):
-        super().__init__(loop, peer_manager, routing_table, protocol, key, bottom_out_limit, max_results, exclude,
+        super().__init__(loop, protocol, key, max_results, shortlist)
                         shortlist)
        self.yielded_peers: typing.Set['KademliaPeer'] = set()
    async def send_probe(self, peer: 'KademliaPeer') -> FindNodeResponse:
-        log.debug("probing %s:%d %s", peer.address, peer.udp_port, hexlify(peer.node_id)[:8] if peer.node_id else '')
+        log.debug("probe %s:%d (%s) for NODE %s",
                  peer.address, peer.udp_port, peer.node_id.hex()[:8] if peer.node_id else '', self.key.hex()[:8])
        response = await self.protocol.get_rpc_peer(peer).find_node(self.key)
        return FindNodeResponse(self.key, response)
    def search_exhausted(self):
-        self.put_result(self.active, finish=True)
+        self.put_result(self.active.keys(), finish=True)
    def put_result(self, from_iter: typing.Iterable['KademliaPeer'], finish=False):
        not_yet_yielded = [
            peer for peer in from_iter
            if peer not in self.yielded_peers
-               and peer.node_id != self.protocol.node_id
+            and peer.node_id != self.protocol.node_id
-               and self.peer_manager.peer_is_good(peer) is not False
+            and self.peer_manager.peer_is_good(peer) is True  # return only peers who answered
        ]
        not_yet_yielded.sort(key=lambda peer: self.distance(peer.node_id))
-        to_yield = not_yet_yielded[:min(constants.k, len(not_yet_yielded))]
+        to_yield = not_yet_yielded[:max(constants.K, self.max_results)]
        if to_yield:
            self.yielded_peers.update(to_yield)
            self.iteration_queue.put_nowait(to_yield)
@ -298,27 +296,15 @@ class IterativeNodeFinder(IterativeFinder):
        if found:
            log.debug("found")
-            return self.put_result(self.active, finish=True)
+            return self.put_result(self.active.keys(), finish=True)
        if self.prev_closest_peer and self.closest_peer and not self._is_closer(self.prev_closest_peer):
            # log.info("improving, %i %i %i %i %i", len(self.shortlist), len(self.active), len(self.contacted),
            #          self.bottom_out_count, self.iteration_count)
            self.bottom_out_count = 0
        elif self.prev_closest_peer and self.closest_peer:
            self.bottom_out_count += 1
            log.info("bottom out %i %i %i", len(self.active), len(self.contacted), self.bottom_out_count)
        if self.bottom_out_count >= self.bottom_out_limit or self.iteration_count >= self.bottom_out_limit:
            log.info("limit hit")
            self.put_result(self.active, True)
 class IterativeValueFinder(IterativeFinder):
-    def __init__(self, loop: asyncio.AbstractEventLoop, peer_manager: 'PeerManager',
+    def __init__(self, loop: asyncio.AbstractEventLoop,
-                 routing_table: 'TreeRoutingTable', protocol: 'KademliaProtocol', key: bytes,
+                 protocol: 'KademliaProtocol', key: bytes,
-                 bottom_out_limit: typing.Optional[int] = 2, max_results: typing.Optional[int] = constants.k,
+                 max_results: typing.Optional[int] = constants.K,
                 exclude: typing.Optional[typing.List[typing.Tuple[str, int]]] = None,
                 shortlist: typing.Optional[typing.List['KademliaPeer']] = None):
-        super().__init__(loop, peer_manager, routing_table, protocol, key, bottom_out_limit, max_results, exclude,
+        super().__init__(loop, protocol, key, max_results, shortlist)
                         shortlist)
        self.blob_peers: typing.Set['KademliaPeer'] = set()
        # this tracks the index of the most recent page we requested from each peer
        self.peer_pages: typing.DefaultDict['KademliaPeer', int] = defaultdict(int)
@ -326,6 +312,8 @@ class IterativeValueFinder(IterativeFinder):
        self.discovered_peers: typing.Dict['KademliaPeer', typing.Set['KademliaPeer']] = defaultdict(set)
    async def send_probe(self, peer: 'KademliaPeer') -> FindValueResponse:
        log.debug("probe %s:%d (%s) for VALUE %s",
                  peer.address, peer.udp_port, peer.node_id.hex()[:8], self.key.hex()[:8])
        page = self.peer_pages[peer]
        response = await self.protocol.get_rpc_peer(peer).find_value(self.key, page=page)
        parsed = FindValueResponse(self.key, response)
@ -335,7 +323,7 @@ class IterativeValueFinder(IterativeFinder):
        decoded_peers = set()
        for compact_addr in parsed.found_compact_addresses:
            try:
-                decoded_peers.add(self.peer_manager.decode_tcp_peer_from_compact_address(compact_addr))
+                decoded_peers.add(decode_tcp_peer_from_compact_address(compact_addr))
            except ValueError:
                log.warning("misbehaving peer %s:%i returned invalid peer for blob",
                            peer.address, peer.udp_port)
@ -347,8 +335,7 @@ class IterativeValueFinder(IterativeFinder):
                  already_known + len(parsed.found_compact_addresses))
        if len(self.discovered_peers[peer]) != already_known + len(parsed.found_compact_addresses):
            log.warning("misbehaving peer %s:%i returned duplicate peers for blob", peer.address, peer.udp_port)
-            parsed.found_compact_addresses.clear()
+        elif len(parsed.found_compact_addresses) >= constants.K and self.peer_pages[peer] < parsed.pages:
        elif len(parsed.found_compact_addresses) >= constants.k and self.peer_pages[peer] < parsed.pages:
            # the peer returned a full page and indicates it has more
            self.peer_pages[peer] += 1
            if peer in self.contacted:
@ -358,26 +345,15 @@ class IterativeValueFinder(IterativeFinder):
    def check_result_ready(self, response: FindValueResponse):
        if response.found:
-            blob_peers = [self.peer_manager.decode_tcp_peer_from_compact_address(compact_addr)
+            blob_peers = [decode_tcp_peer_from_compact_address(compact_addr)
                          for compact_addr in response.found_compact_addresses]
            to_yield = []
            self.bottom_out_count = 0
            for blob_peer in blob_peers:
                if blob_peer not in self.blob_peers:
                    self.blob_peers.add(blob_peer)
                    to_yield.append(blob_peer)
            if to_yield:
                # log.info("found %i new peers for blob", len(to_yield))
                self.iteration_queue.put_nowait(to_yield)
                # if self.max_results and len(self.blob_peers) >= self.max_results:
                #     log.info("enough blob peers found")
                #     if not self.finished.is_set():
                #         self.finished.set()
        elif self.prev_closest_peer and self.closest_peer:
            self.bottom_out_count += 1
            if self.bottom_out_count >= self.bottom_out_limit:
                log.info("blob peer search bottomed out")
                self.iteration_queue.put_nowait(None)
    def get_initial_result(self) -> typing.List['KademliaPeer']:
        if self.protocol.data_store.has_peers_for_blob(self.key):
--- a/lbry/lbry/dht/protocol/protocol.py
+++ b/lbry/lbry/dht/protocol/protocol.py
@ -3,13 +3,16 @@ import socket
 import functools
 import hashlib
 import asyncio
 import time
 import typing
 import binascii
 import random
 from asyncio.protocols import DatagramProtocol
 from asyncio.transports import DatagramTransport
 from prometheus_client import Gauge, Counter, Histogram
 from lbry.dht import constants
 from lbry.dht.serialization.bencoding import DecodeError
 from lbry.dht.serialization.datagram import decode_datagram, ErrorDatagram, ResponseDatagram, RequestDatagram
 from lbry.dht.serialization.datagram import RESPONSE_TYPE, ERROR_TYPE, PAGE_KEY
 from lbry.dht.error import RemoteException, TransportNotConnected
@ -23,13 +26,18 @@ if typing.TYPE_CHECKING:
 log = logging.getLogger(__name__)
-old_protocol_errors = {
+OLD_PROTOCOL_ERRORS = {
    "findNode() takes exactly 2 arguments (5 given)": "0.19.1",
    "findValue() takes exactly 2 arguments (5 given)": "0.19.1"
 }
 class KademliaRPC:
    stored_blob_metric = Gauge(
        "stored_blobs", "Number of blobs announced by other peers", namespace="dht_node",
        labelnames=("scope",),
    )
    def __init__(self, protocol: 'KademliaProtocol', loop: asyncio.AbstractEventLoop, peer_port: int = 3333):
        self.protocol = protocol
        self.loop = loop
@ -48,35 +56,36 @@ class KademliaRPC:
        return b'pong'
    def store(self, rpc_contact: 'KademliaPeer', blob_hash: bytes, token: bytes, port: int) -> bytes:
-        if len(blob_hash) != constants.hash_bits // 8:
+        if len(blob_hash) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid length of blob hash: {len(blob_hash)}")
        if not 0 < port < 65535:
            raise ValueError(f"invalid tcp port: {port}")
        rpc_contact.update_tcp_port(port)
        if not self.verify_token(token, rpc_contact.compact_ip()):
-            if self.loop.time() - self.protocol.started_listening_time < constants.token_secret_refresh_interval:
+            if self.loop.time() - self.protocol.started_listening_time < constants.TOKEN_SECRET_REFRESH_INTERVAL:
                pass
            else:
                raise ValueError("Invalid token")
        self.protocol.data_store.add_peer_to_blob(
            rpc_contact, blob_hash
        )
        self.stored_blob_metric.labels("global").set(len(self.protocol.data_store))
        return b'OK'
    def find_node(self, rpc_contact: 'KademliaPeer', key: bytes) -> typing.List[typing.Tuple[bytes, str, int]]:
-        if len(key) != constants.hash_length:
+        if len(key) != constants.HASH_LENGTH:
            raise ValueError("invalid contact node_id length: %i" % len(key))
        contacts = self.protocol.routing_table.find_close_peers(key, sender_node_id=rpc_contact.node_id)
        contact_triples = []
-        for contact in contacts[:constants.k * 2]:
+        for contact in contacts[:constants.K * 2]:
            contact_triples.append((contact.node_id, contact.address, contact.udp_port))
        return contact_triples
    def find_value(self, rpc_contact: 'KademliaPeer', key: bytes, page: int = 0):
        page = page if page > 0 else 0
-        if len(key) != constants.hash_length:
+        if len(key) != constants.HASH_LENGTH:
            raise ValueError("invalid blob_exchange hash length: %i" % len(key))
        response = {
@ -84,7 +93,7 @@ class KademliaRPC:
        }
        if not page:
-            response[b'contacts'] = self.find_node(rpc_contact, key)[:constants.k]
+            response[b'contacts'] = self.find_node(rpc_contact, key)[:constants.K]
        if self.protocol.protocol_version:
            response[b'protocolVersion'] = self.protocol.protocol_version
@ -96,16 +105,16 @@ class KademliaRPC:
            if not rpc_contact.tcp_port or peer.compact_address_tcp() != rpc_contact.compact_address_tcp()
        ]
        # if we don't have k storing peers to return and we have this hash locally, include our contact information
-        if len(peers) < constants.k and binascii.hexlify(key).decode() in self.protocol.data_store.completed_blobs:
+        if len(peers) < constants.K and key.hex() in self.protocol.data_store.completed_blobs:
            peers.append(self.compact_address())
        if not peers:
            response[PAGE_KEY] = 0
        else:
-            response[PAGE_KEY] = (len(peers) // (constants.k + 1)) + 1  # how many pages of peers we have for the blob
+            response[PAGE_KEY] = (len(peers) // (constants.K + 1)) + 1  # how many pages of peers we have for the blob
-        if len(peers) > constants.k:
+        if len(peers) > constants.K:
            random.Random(self.protocol.node_id).shuffle(peers)
-        if page * constants.k < len(peers):
+        if page * constants.K < len(peers):
-            response[key] = peers[page * constants.k:page * constants.k + constants.k]
+            response[key] = peers[page * constants.K:page * constants.K + constants.K]
        return response
    def refresh_token(self):  # TODO: this needs to be called periodically
@ -154,7 +163,7 @@ class RemoteKademliaRPC:
        :param blob_hash: blob hash as bytes
        :return: b'OK'
        """
-        if len(blob_hash) != constants.hash_bits // 8:
+        if len(blob_hash) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid length of blob hash: {len(blob_hash)}")
        if not self.protocol.peer_port or not 0 < self.protocol.peer_port < 65535:
            raise ValueError(f"invalid tcp port: {self.protocol.peer_port}")
@ -171,7 +180,7 @@ class RemoteKademliaRPC:
        """
        :return: [(node_id, address, udp_port), ...]
        """
-        if len(key) != constants.hash_bits // 8:
+        if len(key) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid length of find node key: {len(key)}")
        response = await self.protocol.send_request(
            self.peer, RequestDatagram.make_find_node(self.protocol.node_id, key)
@ -186,7 +195,7 @@ class RemoteKademliaRPC:
            <key bytes>: [<blob_peer_compact_address, ...]
        }
        """
-        if len(key) != constants.hash_bits // 8:
+        if len(key) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid length of find value key: {len(key)}")
        response = await self.protocol.send_request(
            self.peer, RequestDatagram.make_find_value(self.protocol.node_id, key, page=page)
@ -203,12 +212,16 @@ class PingQueue:
        self._process_task: asyncio.Task = None
        self._running = False
        self._running_pings: typing.Set[asyncio.Task] = set()
-        self._default_delay = constants.maybe_ping_delay
+        self._default_delay = constants.MAYBE_PING_DELAY
    @property
    def running(self):
        return self._running
    @property
    def busy(self):
        return self._running and (any(self._running_pings) or any(self._pending_contacts))
    def enqueue_maybe_ping(self, *peers: 'KademliaPeer', delay: typing.Optional[float] = None):
        delay = delay if delay is not None else self._default_delay
        now = self._loop.time()
@ -220,11 +233,11 @@ class PingQueue:
        async def ping_task():
            try:
                if self._protocol.peer_manager.peer_is_good(peer):
-                    if peer not in self._protocol.routing_table.get_peers():
+                    if not self._protocol.routing_table.get_peer(peer.node_id):
                        self._protocol.add_peer(peer)
                    return
                await self._protocol.get_rpc_peer(peer).ping()
-            except asyncio.TimeoutError:
+            except (asyncio.TimeoutError, RemoteException):
                pass
        task = self._loop.create_task(ping_task())
@ -240,7 +253,7 @@ class PingQueue:
                    del self._pending_contacts[peer]
                    self.maybe_ping(peer)
                    break
-            await asyncio.sleep(1, loop=self._loop)
+            await asyncio.sleep(1)
    def start(self):
        assert not self._running
@ -259,9 +272,33 @@ class PingQueue:
 class KademliaProtocol(DatagramProtocol):
    request_sent_metric = Counter(
        "request_sent", "Number of requests send from DHT RPC protocol", namespace="dht_node",
        labelnames=("method",),
    )
    request_success_metric = Counter(
        "request_success", "Number of successful requests", namespace="dht_node",
        labelnames=("method",),
    )
    request_error_metric = Counter(
        "request_error", "Number of errors returned from request to other peers", namespace="dht_node",
        labelnames=("method",),
    )
    HISTOGRAM_BUCKETS = (
        .005, .01, .025, .05, .075, .1, .25, .5, .75, 1.0, 2.5, 3.0, 3.5, 4.0, 4.50, 5.0, 5.50, 6.0, float('inf')
    )
    response_time_metric = Histogram(
        "response_time", "Response times of DHT RPC requests", namespace="dht_node", buckets=HISTOGRAM_BUCKETS,
        labelnames=("method",)
    )
    received_request_metric = Counter(
        "received_request", "Number of received DHT RPC requests", namespace="dht_node",
        labelnames=("method",),
    )
    def __init__(self, loop: asyncio.AbstractEventLoop, peer_manager: 'PeerManager', node_id: bytes, external_ip: str,
-                 udp_port: int, peer_port: int, rpc_timeout: float = constants.rpc_timeout,
+                 udp_port: int, peer_port: int, rpc_timeout: float = constants.RPC_TIMEOUT,
-                 split_buckets_under_index: int = constants.split_buckets_under_index):
+                 split_buckets_under_index: int = constants.SPLIT_BUCKETS_UNDER_INDEX, is_boostrap_node: bool = False):
        self.peer_manager = peer_manager
        self.loop = loop
        self.node_id = node_id
@ -271,20 +308,21 @@ class KademliaProtocol(DatagramProtocol):
        self.is_seed_node = False
        self.partial_messages: typing.Dict[bytes, typing.Dict[bytes, bytes]] = {}
        self.sent_messages: typing.Dict[bytes, typing.Tuple['KademliaPeer', asyncio.Future, RequestDatagram]] = {}
-        self.protocol_version = constants.protocol_version
+        self.protocol_version = constants.PROTOCOL_VERSION
        self.started_listening_time = 0
        self.transport: DatagramTransport = None
        self.old_token_secret = constants.generate_id()
        self.token_secret = constants.generate_id()
-        self.routing_table = TreeRoutingTable(self.loop, self.peer_manager, self.node_id, split_buckets_under_index)
+        self.routing_table = TreeRoutingTable(
            self.loop, self.peer_manager, self.node_id, split_buckets_under_index, is_bootstrap_node=is_boostrap_node)
        self.data_store = DictDataStore(self.loop, self.peer_manager)
        self.ping_queue = PingQueue(self.loop, self)
        self.node_rpc = KademliaRPC(self, self.loop, self.peer_port)
        self.rpc_timeout = rpc_timeout
-        self._split_lock = asyncio.Lock(loop=self.loop)
+        self._split_lock = asyncio.Lock()
        self._to_remove: typing.Set['KademliaPeer'] = set()
        self._to_add: typing.Set['KademliaPeer'] = set()
-        self._wakeup_routing_task = asyncio.Event(loop=self.loop)
+        self._wakeup_routing_task = asyncio.Event()
        self.maintaing_routing_task: typing.Optional[asyncio.Task] = None
    @functools.lru_cache(128)
@ -323,72 +361,10 @@ class KademliaProtocol(DatagramProtocol):
        return args, {}
    async def _add_peer(self, peer: 'KademliaPeer'):
-        if not peer.node_id:
+        async def probe(some_peer: 'KademliaPeer'):
-            log.warning("Tried adding a peer with no node id!")
+            rpc_peer = self.get_rpc_peer(some_peer)
-            return False
+            await rpc_peer.ping()
-        for p in self.routing_table.get_peers():
+        return await self.routing_table.add_peer(peer, probe)
            if (p.address, p.udp_port) == (peer.address, peer.udp_port) and p.node_id != peer.node_id:
                self.routing_table.remove_peer(p)
                self.routing_table.join_buckets()
        bucket_index = self.routing_table.kbucket_index(peer.node_id)
        if self.routing_table.buckets[bucket_index].add_peer(peer):
            return True
        # The bucket is full; see if it can be split (by checking if its range includes the host node's node_id)
        if self.routing_table.should_split(bucket_index, peer.node_id):
            self.routing_table.split_bucket(bucket_index)
            # Retry the insertion attempt
            result = await self._add_peer(peer)
            self.routing_table.join_buckets()
            return result
        else:
            # We can't split the k-bucket
            #
            # The 13 page kademlia paper specifies that the least recently contacted node in the bucket
            # shall be pinged. If it fails to reply it is replaced with the new contact. If the ping is successful
            # the new contact is ignored and not added to the bucket (sections 2.2 and 2.4).
            #
            # A reasonable extension to this is BEP 0005, which extends the above:
            #
            #    Not all nodes that we learn about are equal. Some are "good" and some are not.
            #    Many nodes using the DHT are able to send queries and receive responses,
            #    but are not able to respond to queries from other nodes. It is important that
            #    each node's routing table must contain only known good nodes. A good node is
            #    a node has responded to one of our queries within the last 15 minutes. A node
            #    is also good if it has ever responded to one of our queries and has sent us a
            #    query within the last 15 minutes. After 15 minutes of inactivity, a node becomes
            #    questionable. Nodes become bad when they fail to respond to multiple queries
            #    in a row. Nodes that we know are good are given priority over nodes with unknown status.
            #
            # When there are bad or questionable nodes in the bucket, the least recent is selected for
            # potential replacement (BEP 0005). When all nodes in the bucket are fresh, the head (least recent)
            # contact is selected as described in section 2.2 of the kademlia paper. In both cases the new contact
            # is ignored if the pinged node replies.
            not_good_contacts = self.routing_table.buckets[bucket_index].get_bad_or_unknown_peers()
            not_recently_replied = []
            for p in not_good_contacts:
                last_replied = self.peer_manager.get_last_replied(p.address, p.udp_port)
                if not last_replied or last_replied + 60 < self.loop.time():
                    not_recently_replied.append(p)
            if not_recently_replied:
                to_replace = not_recently_replied[0]
            else:
                to_replace = self.routing_table.buckets[bucket_index].peers[0]
                last_replied = self.peer_manager.get_last_replied(to_replace.address, to_replace.udp_port)
                if last_replied and last_replied + 60 > self.loop.time():
                    return False
            log.debug("pinging %s:%s", to_replace.address, to_replace.udp_port)
            try:
                to_replace_rpc = self.get_rpc_peer(to_replace)
                await to_replace_rpc.ping()
                return False
            except asyncio.TimeoutError:
                log.debug("Replacing dead contact in bucket %i: %s:%i with %s:%i ", bucket_index,
                          to_replace.address, to_replace.udp_port, peer.address, peer.udp_port)
                if to_replace in self.routing_table.buckets[bucket_index]:
                    self.routing_table.buckets[bucket_index].remove_peer(to_replace)
                return await self._add_peer(peer)
    def add_peer(self, peer: 'KademliaPeer'):
        if peer.node_id == self.node_id:
@ -406,35 +382,34 @@ class KademliaProtocol(DatagramProtocol):
                async with self._split_lock:
                    peer = self._to_remove.pop()
                    self.routing_table.remove_peer(peer)
                    self.routing_table.join_buckets()
            while self._to_add:
                async with self._split_lock:
                    await self._add_peer(self._to_add.pop())
-            await asyncio.gather(self._wakeup_routing_task.wait(), asyncio.sleep(.1, loop=self.loop), loop=self.loop)
+            await asyncio.gather(self._wakeup_routing_task.wait(), asyncio.sleep(.1))
            self._wakeup_routing_task.clear()
    def _handle_rpc(self, sender_contact: 'KademliaPeer', message: RequestDatagram):
-        assert sender_contact.node_id != self.node_id, (binascii.hexlify(sender_contact.node_id)[:8].decode(),
+        assert sender_contact.node_id != self.node_id, (sender_contact.node_id.hex()[:8],
-                                                        binascii.hexlify(self.node_id)[:8].decode())
+                                                        self.node_id.hex()[:8])
        method = message.method
        if method not in [b'ping', b'store', b'findNode', b'findValue']:
            raise AttributeError('Invalid method: %s' % message.method.decode())
        if message.args and isinstance(message.args[-1], dict) and b'protocolVersion' in message.args[-1]:
            # args don't need reformatting
-            args, kw = tuple(message.args[:-1]), message.args[-1]
+            args, kwargs = tuple(message.args[:-1]), message.args[-1]
        else:
-            args, kw = self._migrate_incoming_rpc_args(sender_contact, message.method, *message.args)
+            args, kwargs = self._migrate_incoming_rpc_args(sender_contact, message.method, *message.args)
        log.debug("%s:%i RECV CALL %s %s:%i", self.external_ip, self.udp_port, message.method.decode(),
                  sender_contact.address, sender_contact.udp_port)
        if method == b'ping':
            result = self.node_rpc.ping()
        elif method == b'store':
-            blob_hash, token, port, original_publisher_id, age = args[:5]
+            blob_hash, token, port, original_publisher_id, age = args[:5]  # pylint: disable=unused-variable
            result = self.node_rpc.store(sender_contact, blob_hash, token, port)
        else:
            key = args[0]
-            page = kw.get(PAGE_KEY, 0)
+            page = kwargs.get(PAGE_KEY, 0)
            if method == b'findNode':
                result = self.node_rpc.find_node(sender_contact, key)
            else:
@ -447,11 +422,15 @@ class KademliaProtocol(DatagramProtocol):
    def handle_request_datagram(self, address: typing.Tuple[str, int], request_datagram: RequestDatagram):
        # This is an RPC method request
        self.received_request_metric.labels(method=request_datagram.method).inc()
        self.peer_manager.report_last_requested(address[0], address[1])
-        try:
+        peer = self.routing_table.get_peer(request_datagram.node_id)
-            peer = self.routing_table.get_peer(request_datagram.node_id)
+        if not peer:
-        except IndexError:
+            try:
-            peer = make_kademlia_peer(request_datagram.node_id, address[0], address[1])
+                peer = make_kademlia_peer(request_datagram.node_id, address[0], address[1])
            except ValueError as err:
                log.warning("error replying to %s: %s", address[0], str(err))
                return
        try:
            self._handle_rpc(peer, request_datagram)
            # if the contact is not known to be bad (yet) and we haven't yet queried it, send it a ping so that it
@ -484,25 +463,25 @@ class KademliaProtocol(DatagramProtocol):
    def handle_response_datagram(self, address: typing.Tuple[str, int], response_datagram: ResponseDatagram):
        # Find the message that triggered this response
        if response_datagram.rpc_id in self.sent_messages:
-            peer, df, request = self.sent_messages[response_datagram.rpc_id]
+            peer, future, _ = self.sent_messages[response_datagram.rpc_id]
            if peer.address != address[0]:
-                df.set_exception(RemoteException(
+                future.set_exception(
-                    f"response from {address[0]}, expected {peer.address}")
+                    RemoteException(f"response from {address[0]}, expected {peer.address}")
                )
                return
            # We got a result from the RPC
            if peer.node_id == self.node_id:
-                df.set_exception(RemoteException("node has our node id"))
+                future.set_exception(RemoteException("node has our node id"))
                return
            elif response_datagram.node_id == self.node_id:
-                df.set_exception(RemoteException("incoming message is from our node id"))
+                future.set_exception(RemoteException("incoming message is from our node id"))
                return
            peer = make_kademlia_peer(response_datagram.node_id, address[0], address[1])
            self.peer_manager.report_last_replied(address[0], address[1])
            self.peer_manager.update_contact_triple(peer.node_id, address[0], address[1])
-            if not df.cancelled():
+            if not future.cancelled():
-                df.set_result(response_datagram)
+                future.set_result(response_datagram)
                self.add_peer(peer)
            else:
                log.warning("%s:%i replied, but after we cancelled the request attempt",
@ -516,11 +495,13 @@ class KademliaProtocol(DatagramProtocol):
        # The RPC request raised a remote exception; raise it locally
        remote_exception = RemoteException(f"{error_datagram.exception_type}({error_datagram.response})")
        if error_datagram.rpc_id in self.sent_messages:
-            peer, df, request = self.sent_messages.pop(error_datagram.rpc_id)
+            peer, future, request = self.sent_messages.pop(error_datagram.rpc_id)
            if (peer.address, peer.udp_port) != address:
-                df.set_exception(RemoteException(
+                future.set_exception(
-                    f"response from {address[0]}:{address[1]}, "
+                    RemoteException(
-                    f"expected {peer.address}:{peer.udp_port}")
+                        f"response from {address[0]}:{address[1]}, "
                        f"expected {peer.address}:{peer.udp_port}"
                    )
                )
                return
            error_msg = f"" \
@ -529,28 +510,32 @@ class KademliaProtocol(DatagramProtocol):
                f"Raised: {str(remote_exception)}"
            if 'Invalid token' in error_msg:
                log.debug(error_msg)
-            elif error_datagram.response not in old_protocol_errors:
+            elif error_datagram.response not in OLD_PROTOCOL_ERRORS:
                log.warning(error_msg)
            else:
-                log.debug("known dht protocol backwards compatibility error with %s:%i (lbrynet v%s)",
+                log.debug(
-                            peer.address, peer.udp_port, old_protocol_errors[error_datagram.response])
+                    "known dht protocol backwards compatibility error with %s:%i (lbrynet v%s)",
-            df.set_exception(remote_exception)
+                    peer.address, peer.udp_port, OLD_PROTOCOL_ERRORS[error_datagram.response]
                )
            future.set_exception(remote_exception)
            return
        else:
-            if error_datagram.response not in old_protocol_errors:
+            if error_datagram.response not in OLD_PROTOCOL_ERRORS:
                msg = f"Received error from {address[0]}:{address[1]}, but it isn't in response to a " \
                    f"pending request: {str(remote_exception)}"
                log.warning(msg)
            else:
-                log.debug("known dht protocol backwards compatibility error with %s:%i (lbrynet v%s)",
+                log.debug(
-                            address[0], address[1], old_protocol_errors[error_datagram.response])
+                    "known dht protocol backwards compatibility error with %s:%i (lbrynet v%s)",
                    address[0], address[1], OLD_PROTOCOL_ERRORS[error_datagram.response]
                )
-    def datagram_received(self, datagram: bytes, address: typing.Tuple[str, int]) -> None:
+    def datagram_received(self, datagram: bytes, address: typing.Tuple[str, int]) -> None:  # pylint: disable=arguments-renamed
        try:
            message = decode_datagram(datagram)
-        except (ValueError, TypeError):
+        except (ValueError, TypeError, DecodeError):
            self.peer_manager.report_failure(address[0], address[1])
-            log.warning("Couldn't decode dht datagram from %s: %s", address, binascii.hexlify(datagram).decode())
+            log.warning("Couldn't decode dht datagram from %s: %s", address, datagram.hex())
            return
        if isinstance(message, RequestDatagram):
@ -565,14 +550,19 @@ class KademliaProtocol(DatagramProtocol):
        self._send(peer, request)
        response_fut = self.sent_messages[request.rpc_id][1]
        try:
            self.request_sent_metric.labels(method=request.method).inc()
            start = time.perf_counter()
            response = await asyncio.wait_for(response_fut, self.rpc_timeout)
            self.response_time_metric.labels(method=request.method).observe(time.perf_counter() - start)
            self.peer_manager.report_last_replied(peer.address, peer.udp_port)
            self.request_success_metric.labels(method=request.method).inc()
            return response
        except asyncio.CancelledError:
            if not response_fut.done():
                response_fut.cancel()
            raise
        except (asyncio.TimeoutError, RemoteException):
            self.request_error_metric.labels(method=request.method).inc()
            self.peer_manager.report_failure(peer.address, peer.udp_port)
            if self.peer_manager.peer_is_good(peer) is False:
                self.remove_peer(peer)
@ -589,12 +579,12 @@ class KademliaProtocol(DatagramProtocol):
            raise TransportNotConnected()
        data = message.bencode()
-        if len(data) > constants.msg_size_limit:
+        if len(data) > constants.MSG_SIZE_LIMIT:
            log.warning("cannot send datagram larger than %i bytes (packet is %i bytes)",
-                        constants.msg_size_limit, len(data))
+                        constants.MSG_SIZE_LIMIT, len(data))
-            log.debug("Packet is too large to send: %s", binascii.hexlify(data[:3500]).decode())
+            log.debug("Packet is too large to send: %s", data[:3500].hex())
            raise ValueError(
-                f"cannot send datagram larger than {constants.msg_size_limit} bytes (packet is {len(data)} bytes)"
+                f"cannot send datagram larger than {constants.MSG_SIZE_LIMIT} bytes (packet is {len(data)} bytes)"
            )
        if isinstance(message, (RequestDatagram, ResponseDatagram)):
            assert message.node_id == self.node_id, message
@ -637,38 +627,38 @@ class KademliaProtocol(DatagramProtocol):
        return constants.digest(self.token_secret + compact_ip)
    def verify_token(self, token, compact_ip):
-        h = constants.hash_class()
+        h = constants.HASH_CLASS()
        h.update(self.token_secret + compact_ip)
        if self.old_token_secret and not token == h.digest():  # TODO: why should we be accepting the previous token?
-            h = constants.hash_class()
+            h = constants.HASH_CLASS()
            h.update(self.old_token_secret + compact_ip)
            if not token == h.digest():
                return False
        return True
-    async def store_to_peer(self, hash_value: bytes, peer: 'KademliaPeer',
+    async def store_to_peer(self, hash_value: bytes, peer: 'KademliaPeer',  # pylint: disable=too-many-return-statements
                            retry: bool = True) -> typing.Tuple[bytes, bool]:
        async def __store():
            res = await self.get_rpc_peer(peer).store(hash_value)
            if res != b"OK":
                raise ValueError(res)
-            log.debug("Stored %s to %s", binascii.hexlify(hash_value).decode()[:8], peer)
+            log.debug("Stored %s to %s", hash_value.hex()[:8], peer)
            return peer.node_id, True
        try:
            return await __store()
        except asyncio.TimeoutError:
-            log.debug("Timeout while storing blob_hash %s at %s", binascii.hexlify(hash_value).decode()[:8], peer)
+            log.debug("Timeout while storing blob_hash %s at %s", hash_value.hex()[:8], peer)
            return peer.node_id, False
        except ValueError as err:
-            log.error("Unexpected response: %s" % err)
+            log.error("Unexpected response: %s", err)
            return peer.node_id, False
        except RemoteException as err:
            if 'findValue() takes exactly 2 arguments (5 given)' in str(err):
                log.debug("peer %s:%i is running an incompatible version of lbrynet", peer.address, peer.udp_port)
                return peer.node_id, False
            if 'Invalid token' not in str(err):
-                log.exception("Unexpected error while storing blob_hash")
+                log.warning("Unexpected error while storing blob_hash: %s", err)
                return peer.node_id, False
        self.peer_manager.clear_token(peer.node_id)
        if not retry:
--- a/lbry/lbry/dht/protocol/routing_table.py
+++ b/lbry/lbry/dht/protocol/routing_table.py
@ -4,7 +4,11 @@ import logging
 import typing
 import itertools
 from prometheus_client import Gauge
 from lbry import utils
 from lbry.dht import constants
 from lbry.dht.error import RemoteException
 from lbry.dht.protocol.distance import Distance
 if typing.TYPE_CHECKING:
    from lbry.dht.peer import KademliaPeer, PeerManager
@ -13,10 +17,20 @@ log = logging.getLogger(__name__)
 class KBucket:
    """ Description - later
    """
    Kademlia K-bucket implementation.
    """
    peer_in_routing_table_metric = Gauge(
        "peers_in_routing_table", "Number of peers on routing table", namespace="dht_node",
        labelnames=("scope",)
    )
    peer_with_x_bit_colliding_metric = Gauge(
        "peer_x_bit_colliding", "Number of peers with at least X bits colliding with this node id",
        namespace="dht_node", labelnames=("amount",)
    )
-    def __init__(self, peer_manager: 'PeerManager', range_min: int, range_max: int, node_id: bytes):
+    def __init__(self, peer_manager: 'PeerManager', range_min: int, range_max: int,
                 node_id: bytes, capacity: int = constants.K):
        """
        @param range_min: The lower boundary for the range in the n-bit ID
                         space covered by this k-bucket
@ -24,12 +38,12 @@ class KBucket:
                         covered by this k-bucket
        """
        self._peer_manager = peer_manager
        self.last_accessed = 0
        self.range_min = range_min
        self.range_max = range_max
        self.peers: typing.List['KademliaPeer'] = []
        self._node_id = node_id
        self._distance_to_self = Distance(node_id)
        self.capacity = capacity
    def add_peer(self, peer: 'KademliaPeer') -> bool:
        """ Add contact to _contact list in the right order. This will move the
@ -50,24 +64,25 @@ class KBucket:
            self.peers.append(peer)
            return True
        else:
-            for i in range(len(self.peers)):
+            for i, _ in enumerate(self.peers):
-                p = self.peers[i]
+                local_peer = self.peers[i]
-                if p.node_id == peer.node_id:
+                if local_peer.node_id == peer.node_id:
-                    self.peers.remove(p)
+                    self.peers.remove(local_peer)
                    self.peers.append(peer)
                    return True
-        if len(self.peers) < constants.k:
+        if len(self.peers) < self.capacity:
            self.peers.append(peer)
            self.peer_in_routing_table_metric.labels("global").inc()
            bits_colliding = utils.get_colliding_prefix_bits(peer.node_id, self._node_id)
            self.peer_with_x_bit_colliding_metric.labels(amount=bits_colliding).inc()
            return True
        else:
            return False
            # raise BucketFull("No space in bucket to insert contact")
    def get_peer(self, node_id: bytes) -> 'KademliaPeer':
        for peer in self.peers:
            if peer.node_id == node_id:
                return peer
        raise IndexError(node_id)
    def get_peers(self, count=-1, exclude_contact=None, sort_distance_to=None) -> typing.List['KademliaPeer']:
        """ Returns a list containing up to the first count number of contacts
@ -101,8 +116,8 @@ class KBucket:
        current_len = len(peers)
        # If count greater than k - return only k contacts
-        if count > constants.k:
+        if count > constants.K:
-            count = constants.k
+            count = constants.K
        if not current_len:
            return peers
@ -124,6 +139,9 @@ class KBucket:
    def remove_peer(self, peer: 'KademliaPeer') -> None:
        self.peers.remove(peer)
        self.peer_in_routing_table_metric.labels("global").dec()
        bits_colliding = utils.get_colliding_prefix_bits(peer.node_id, self._node_id)
        self.peer_with_x_bit_colliding_metric.labels(amount=bits_colliding).dec()
    def key_in_range(self, key: bytes) -> bool:
        """ Tests whether the specified key (i.e. node ID) is in the range
@ -161,31 +179,43 @@ class TreeRoutingTable:
    version of the Kademlia paper, in section 2.4. It does, however, use the
    ping RPC-based k-bucket eviction algorithm described in section 2.2 of
    that paper.
    BOOTSTRAP MODE: if set to True, we always add all peers. This is so a
    bootstrap node does not get a bias towards its own node id and replies are
    the best it can provide (joining peer knows its neighbors immediately).
    Over time, this will need to be optimized so we use the disk as holding
    everything in memory won't be feasible anymore.
    See: https://github.com/bittorrent/bootstrap-dht
    """
    bucket_in_routing_table_metric = Gauge(
        "buckets_in_routing_table", "Number of buckets on routing table", namespace="dht_node",
        labelnames=("scope",)
    )
    def __init__(self, loop: asyncio.AbstractEventLoop, peer_manager: 'PeerManager', parent_node_id: bytes,
-                 split_buckets_under_index: int = constants.split_buckets_under_index):
+                 split_buckets_under_index: int = constants.SPLIT_BUCKETS_UNDER_INDEX, is_bootstrap_node: bool = False):
        self._loop = loop
        self._peer_manager = peer_manager
        self._parent_node_id = parent_node_id
        self._split_buckets_under_index = split_buckets_under_index
        self.buckets: typing.List[KBucket] = [
            KBucket(
-                self._peer_manager, range_min=0, range_max=2 ** constants.hash_bits, node_id=self._parent_node_id
+                self._peer_manager, range_min=0, range_max=2 ** constants.HASH_BITS, node_id=self._parent_node_id,
                capacity=1 << 32 if is_bootstrap_node else constants.K
            )
        ]
    def get_peers(self) -> typing.List['KademliaPeer']:
        return list(itertools.chain.from_iterable(map(lambda bucket: bucket.peers, self.buckets)))
-    def should_split(self, bucket_index: int, to_add: bytes) -> bool:
+    def _should_split(self, bucket_index: int, to_add: bytes) -> bool:
        #  https://stackoverflow.com/questions/32129978/highly-unbalanced-kademlia-routing-table/32187456#32187456
        if bucket_index < self._split_buckets_under_index:
            return True
        contacts = self.get_peers()
        distance = Distance(self._parent_node_id)
        contacts.sort(key=lambda c: distance(c.node_id))
-        kth_contact = contacts[-1] if len(contacts) < constants.k else contacts[constants.k - 1]
+        kth_contact = contacts[-1] if len(contacts) < constants.K else contacts[constants.K - 1]
        return distance(to_add) < distance(kth_contact.node_id)
    def find_close_peers(self, key: bytes, count: typing.Optional[int] = None,
@ -193,7 +223,7 @@ class TreeRoutingTable:
        exclude = [self._parent_node_id]
        if sender_node_id:
            exclude.append(sender_node_id)
-        count = count or constants.k
+        count = count or constants.K
        distance = Distance(key)
        contacts = self.get_peers()
        contacts = [c for c in contacts if c.node_id not in exclude]
@ -203,39 +233,32 @@ class TreeRoutingTable:
        return []
    def get_peer(self, contact_id: bytes) -> 'KademliaPeer':
-        """
+        return self.buckets[self._kbucket_index(contact_id)].get_peer(contact_id)
        @raise IndexError: No contact with the specified contact ID is known
                           by this node
        """
        return self.buckets[self.kbucket_index(contact_id)].get_peer(contact_id)
    def get_refresh_list(self, start_index: int = 0, force: bool = False) -> typing.List[bytes]:
        bucket_index = start_index
        refresh_ids = []
-        now = int(self._loop.time())
+        for offset, _ in enumerate(self.buckets[start_index:]):
-        for bucket in self.buckets[start_index:]:
+            refresh_ids.append(self._midpoint_id_in_bucket_range(start_index + offset))
-            if force or now - bucket.last_accessed >= constants.refresh_interval:
+        # if we have 3 or fewer populated buckets get two random ids in the range of each to try and
-                to_search = self.midpoint_id_in_bucket_range(bucket_index)
+        # populate/split the buckets further
-                refresh_ids.append(to_search)
+        buckets_with_contacts = self.buckets_with_contacts()
-            bucket_index += 1
+        if buckets_with_contacts <= 3:
            for i in range(buckets_with_contacts):
                refresh_ids.append(self._random_id_in_bucket_range(i))
                refresh_ids.append(self._random_id_in_bucket_range(i))
        return refresh_ids
    def remove_peer(self, peer: 'KademliaPeer') -> None:
        if not peer.node_id:
            return
-        bucket_index = self.kbucket_index(peer.node_id)
+        bucket_index = self._kbucket_index(peer.node_id)
        try:
            self.buckets[bucket_index].remove_peer(peer)
            self._join_buckets()
        except ValueError:
            return
-    def touch_kbucket(self, key: bytes) -> None:
+    def _kbucket_index(self, key: bytes) -> int:
        self.touch_kbucket_by_index(self.kbucket_index(key))
    def touch_kbucket_by_index(self, bucket_index: int):
        self.buckets[bucket_index].last_accessed = int(self._loop.time())
    def kbucket_index(self, key: bytes) -> int:
        i = 0
        for bucket in self.buckets:
            if bucket.key_in_range(key):
@ -244,19 +267,19 @@ class TreeRoutingTable:
                i += 1
        return i
-    def random_id_in_bucket_range(self, bucket_index: int) -> bytes:
+    def _random_id_in_bucket_range(self, bucket_index: int) -> bytes:
        random_id = int(random.randrange(self.buckets[bucket_index].range_min, self.buckets[bucket_index].range_max))
        return Distance(
            self._parent_node_id
-        )(random_id.to_bytes(constants.hash_length, 'big')).to_bytes(constants.hash_length, 'big')
+        )(random_id.to_bytes(constants.HASH_LENGTH, 'big')).to_bytes(constants.HASH_LENGTH, 'big')
-    def midpoint_id_in_bucket_range(self, bucket_index: int) -> bytes:
+    def _midpoint_id_in_bucket_range(self, bucket_index: int) -> bytes:
        half = int((self.buckets[bucket_index].range_max - self.buckets[bucket_index].range_min) // 2)
        return Distance(self._parent_node_id)(
-            int(self.buckets[bucket_index].range_min + half).to_bytes(constants.hash_length, 'big')
+            int(self.buckets[bucket_index].range_min + half).to_bytes(constants.HASH_LENGTH, 'big')
-        ).to_bytes(constants.hash_length, 'big')
+        ).to_bytes(constants.HASH_LENGTH, 'big')
-    def split_bucket(self, old_bucket_index: int) -> None:
+    def _split_bucket(self, old_bucket_index: int) -> None:
        """ Splits the specified k-bucket into two new buckets which together
        cover the same range in the key/ID space
@ -279,11 +302,12 @@ class TreeRoutingTable:
        # ...and remove them from the old bucket
        for contact in new_bucket.peers:
            old_bucket.remove_peer(contact)
        self.bucket_in_routing_table_metric.labels("global").set(len(self.buckets))
-    def join_buckets(self):
+    def _join_buckets(self):
        if len(self.buckets) == 1:
            return
-        to_pop = [i for i, bucket in enumerate(self.buckets) if not len(bucket)]
+        to_pop = [i for i, bucket in enumerate(self.buckets) if len(bucket) == 0]
        if not to_pop:
            return
        log.info("join buckets %i", len(to_pop))
@ -302,18 +326,79 @@ class TreeRoutingTable:
        elif can_go_higher:
            self.buckets[bucket_index_to_pop + 1].range_min = bucket.range_min
        self.buckets.remove(bucket)
-        return self.join_buckets()
+        self.bucket_in_routing_table_metric.labels("global").set(len(self.buckets))
-
+        return self._join_buckets()
    def contact_in_routing_table(self, address_tuple: typing.Tuple[str, int]) -> bool:
        for bucket in self.buckets:
            for contact in bucket.get_peers(sort_distance_to=False):
                if address_tuple[0] == contact.address and address_tuple[1] == contact.udp_port:
                    return True
        return False
    def buckets_with_contacts(self) -> int:
        count = 0
        for bucket in self.buckets:
-            if len(bucket):
+            if len(bucket) > 0:
                count += 1
        return count
    async def add_peer(self, peer: 'KademliaPeer', probe: typing.Callable[['KademliaPeer'], typing.Awaitable]):
        if not peer.node_id:
            log.warning("Tried adding a peer with no node id!")
            return False
        for my_peer in self.get_peers():
            if (my_peer.address, my_peer.udp_port) == (peer.address, peer.udp_port) and my_peer.node_id != peer.node_id:
                self.remove_peer(my_peer)
                self._join_buckets()
        bucket_index = self._kbucket_index(peer.node_id)
        if self.buckets[bucket_index].add_peer(peer):
            return True
        # The bucket is full; see if it can be split (by checking if its range includes the host node's node_id)
        if self._should_split(bucket_index, peer.node_id):
            self._split_bucket(bucket_index)
            # Retry the insertion attempt
            result = await self.add_peer(peer, probe)
            self._join_buckets()
            return result
        else:
            # We can't split the k-bucket
            #
            # The 13 page kademlia paper specifies that the least recently contacted node in the bucket
            # shall be pinged. If it fails to reply it is replaced with the new contact. If the ping is successful
            # the new contact is ignored and not added to the bucket (sections 2.2 and 2.4).
            #
            # A reasonable extension to this is BEP 0005, which extends the above:
            #
            #    Not all nodes that we learn about are equal. Some are "good" and some are not.
            #    Many nodes using the DHT are able to send queries and receive responses,
            #    but are not able to respond to queries from other nodes. It is important that
            #    each node's routing table must contain only known good nodes. A good node is
            #    a node has responded to one of our queries within the last 15 minutes. A node
            #    is also good if it has ever responded to one of our queries and has sent us a
            #    query within the last 15 minutes. After 15 minutes of inactivity, a node becomes
            #    questionable. Nodes become bad when they fail to respond to multiple queries
            #    in a row. Nodes that we know are good are given priority over nodes with unknown status.
            #
            # When there are bad or questionable nodes in the bucket, the least recent is selected for
            # potential replacement (BEP 0005). When all nodes in the bucket are fresh, the head (least recent)
            # contact is selected as described in section 2.2 of the kademlia paper. In both cases the new contact
            # is ignored if the pinged node replies.
            not_good_contacts = self.buckets[bucket_index].get_bad_or_unknown_peers()
            not_recently_replied = []
            for my_peer in not_good_contacts:
                last_replied = self._peer_manager.get_last_replied(my_peer.address, my_peer.udp_port)
                if not last_replied or last_replied + 60 < self._loop.time():
                    not_recently_replied.append(my_peer)
            if not_recently_replied:
                to_replace = not_recently_replied[0]
            else:
                to_replace = self.buckets[bucket_index].peers[0]
                last_replied = self._peer_manager.get_last_replied(to_replace.address, to_replace.udp_port)
                if last_replied and last_replied + 60 > self._loop.time():
                    return False
            log.debug("pinging %s:%s", to_replace.address, to_replace.udp_port)
            try:
                await probe(to_replace)
                return False
            except (asyncio.TimeoutError, RemoteException):
                log.debug("Replacing dead contact in bucket %i: %s:%i with %s:%i ", bucket_index,
                          to_replace.address, to_replace.udp_port, peer.address, peer.udp_port)
                if to_replace in self.buckets[bucket_index]:
                    self.buckets[bucket_index].remove_peer(to_replace)
                return await self.add_peer(peer, probe)
--- a/lbry/dht/serialization/init.py
+++ b/lbry/dht/serialization/init.py
--- a/lbry/lbry/dht/serialization/bencoding.py
+++ b/lbry/lbry/dht/serialization/bencoding.py
@ -52,8 +52,7 @@ def _bdecode(data: bytes, start_index: int = 0) -> typing.Tuple[typing.Union[int
            raise DecodeError(err)
        start_index = split_pos + 1
        end_pos = start_index + length
-        b = data[start_index:end_pos]
+        return data[start_index:end_pos], end_pos
        return b, end_pos
 def bencode(data: typing.Dict) -> bytes:
--- a/lbry/lbry/dht/serialization/datagram.py
+++ b/lbry/lbry/dht/serialization/datagram.py
@ -34,9 +34,9 @@ class KademliaDatagramBase:
        self.packet_type = packet_type
        if self.expected_packet_type != packet_type:
            raise ValueError(f"invalid packet type: {packet_type}, expected {self.expected_packet_type}")
-        if len(rpc_id) != constants.rpc_id_length:
+        if len(rpc_id) != constants.RPC_ID_LENGTH:
            raise ValueError(f"invalid rpc node_id: {len(rpc_id)} bytes (expected 20)")
-        if not len(node_id) == constants.hash_length:
+        if not len(node_id) == constants.HASH_LENGTH:
            raise ValueError(f"invalid node node_id: {len(node_id)} bytes (expected 48)")
        self.rpc_id = rpc_id
        self.node_id = node_id
@ -46,9 +46,9 @@ class KademliaDatagramBase:
            i: getattr(self, k) for i, k in enumerate(self.required_fields)
        }
        for i, k in enumerate(OPTIONAL_FIELDS):
-            v = getattr(self, k, None)
+            value = getattr(self, k, None)
-            if v is not None:
+            if value is not None:
-                datagram[i + OPTIONAL_ARG_OFFSET] = v
+                datagram[i + OPTIONAL_ARG_OFFSET] = value
        return bencode(datagram)
@ -77,18 +77,18 @@ class RequestDatagram(KademliaDatagramBase):
    @classmethod
    def make_ping(cls, from_node_id: bytes, rpc_id: typing.Optional[bytes] = None) -> 'RequestDatagram':
-        rpc_id = rpc_id or constants.generate_id()[:constants.rpc_id_length]
+        rpc_id = rpc_id or constants.generate_id()[:constants.RPC_ID_LENGTH]
        return cls(REQUEST_TYPE, rpc_id, from_node_id, b'ping')
    @classmethod
    def make_store(cls, from_node_id: bytes, blob_hash: bytes, token: bytes, port: int,
                   rpc_id: typing.Optional[bytes] = None) -> 'RequestDatagram':
-        rpc_id = rpc_id or constants.generate_id()[:constants.rpc_id_length]
+        rpc_id = rpc_id or constants.generate_id()[:constants.RPC_ID_LENGTH]
-        if len(blob_hash) != constants.hash_bits // 8:
+        if len(blob_hash) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid blob hash length: {len(blob_hash)}")
        if not 0 < port < 65536:
            raise ValueError(f"invalid port: {port}")
-        if len(token) != constants.hash_bits // 8:
+        if len(token) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid token length: {len(token)}")
        store_args = [blob_hash, token, port, from_node_id, 0]
        return cls(REQUEST_TYPE, rpc_id, from_node_id, b'store', store_args)
@ -96,16 +96,16 @@ class RequestDatagram(KademliaDatagramBase):
    @classmethod
    def make_find_node(cls, from_node_id: bytes, key: bytes,
                       rpc_id: typing.Optional[bytes] = None) -> 'RequestDatagram':
-        rpc_id = rpc_id or constants.generate_id()[:constants.rpc_id_length]
+        rpc_id = rpc_id or constants.generate_id()[:constants.RPC_ID_LENGTH]
-        if len(key) != constants.hash_bits // 8:
+        if len(key) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid key length: {len(key)}")
        return cls(REQUEST_TYPE, rpc_id, from_node_id, b'findNode', [key])
    @classmethod
    def make_find_value(cls, from_node_id: bytes, key: bytes,
                        rpc_id: typing.Optional[bytes] = None, page: int = 0) -> 'RequestDatagram':
-        rpc_id = rpc_id or constants.generate_id()[:constants.rpc_id_length]
+        rpc_id = rpc_id or constants.generate_id()[:constants.RPC_ID_LENGTH]
-        if len(key) != constants.hash_bits // 8:
+        if len(key) != constants.HASH_BITS // 8:
            raise ValueError(f"invalid key length: {len(key)}")
        if page < 0:
            raise ValueError(f"cannot request a negative page ({page})")
@ -144,7 +144,7 @@ class ErrorDatagram(KademliaDatagramBase):
        self.response = response.decode()
-def decode_datagram(datagram: bytes) -> typing.Union[RequestDatagram, ResponseDatagram, ErrorDatagram]:
+def _decode_datagram(datagram: bytes):
    msg_types = {
        REQUEST_TYPE: RequestDatagram,
        RESPONSE_TYPE: ResponseDatagram,
@ -152,26 +152,36 @@ def decode_datagram(datagram: bytes) -> typing.Union[RequestDatagram, ResponseDa
    }
    primitive: typing.Dict = bdecode(datagram)
-    if primitive[0] in [REQUEST_TYPE, ERROR_TYPE, RESPONSE_TYPE]:  # pylint: disable=unsubscriptable-object
+
-        datagram_type = primitive[0]  # pylint: disable=unsubscriptable-object
+    converted = {
        str(k).encode() if not isinstance(k, bytes) else k: v for k, v in primitive.items()
    }
    if converted[b'0'] in [REQUEST_TYPE, ERROR_TYPE, RESPONSE_TYPE]:  # pylint: disable=unsubscriptable-object
        datagram_type = converted[b'0']  # pylint: disable=unsubscriptable-object
    else:
        raise ValueError("invalid datagram type")
    datagram_class = msg_types[datagram_type]
    decoded = {
-        k: primitive[i]  # pylint: disable=unsubscriptable-object
+        k: converted[str(i).encode()]  # pylint: disable=unsubscriptable-object
        for i, k in enumerate(datagram_class.required_fields)
-        if i in primitive  # pylint: disable=unsupported-membership-test
+        if str(i).encode() in converted  # pylint: disable=unsupported-membership-test
    }
-    for i, k in enumerate(OPTIONAL_FIELDS):
+    for i, _ in enumerate(OPTIONAL_FIELDS):
-        if i + OPTIONAL_ARG_OFFSET in primitive:
+        if str(i + OPTIONAL_ARG_OFFSET).encode() in converted:
-            decoded[i + OPTIONAL_ARG_OFFSET] = primitive[i + OPTIONAL_ARG_OFFSET]
+            decoded[i + OPTIONAL_ARG_OFFSET] = converted[str(i + OPTIONAL_ARG_OFFSET).encode()]
    return decoded, datagram_class
 def decode_datagram(datagram: bytes) -> typing.Union[RequestDatagram, ResponseDatagram, ErrorDatagram]:
    decoded, datagram_class = _decode_datagram(datagram)
    return datagram_class(**decoded)
 def make_compact_ip(address: str) -> bytearray:
    compact_ip = reduce(lambda buff, x: buff + bytearray([int(x)]), address.split('.'), bytearray())
    if len(compact_ip) != 4:
-        raise ValueError(f"invalid IPv4 length")
+        raise ValueError("invalid IPv4 length")
    return compact_ip
@ -179,8 +189,8 @@ def make_compact_address(node_id: bytes, address: str, port: int) -> bytearray:
    compact_ip = make_compact_ip(address)
    if not 0 < port < 65536:
        raise ValueError(f'Invalid port: {port}')
-    if len(node_id) != constants.hash_bits // 8:
+    if len(node_id) != constants.HASH_BITS // 8:
-        raise ValueError(f"invalid node node_id length")
+        raise ValueError("invalid node node_id length")
    return compact_ip + port.to_bytes(2, 'big') + node_id
@ -190,6 +200,6 @@ def decode_compact_address(compact_address: bytes) -> typing.Tuple[bytes, str, i
    node_id = compact_address[6:]
    if not 0 < port < 65536:
        raise ValueError(f'Invalid port: {port}')
-    if len(node_id) != constants.hash_bits // 8:
+    if len(node_id) != constants.HASH_BITS // 8:
-        raise ValueError(f"invalid node node_id length")
+        raise ValueError("invalid node node_id length")
    return node_id, address, port
--- a/lbry/docs/api.json
+++ b/lbry/docs/api.json
--- a/lbry/lbry/error/Makefile
+++ b/lbry/lbry/error/Makefile
--- a/lbry/lbry/error/README.md
+++ b/lbry/lbry/error/README.md
@ -34,6 +34,11 @@ Code | Name | Message
 **11x** | InputValue(ValueError) | Invalid argument value provided to command.
 111 | GenericInputValue | The value '{value}' for argument '{argument}' is not valid.
 112 | InputValueIsNone | None or null is not valid value for argument '{argument}'.
 113 | ConflictingInputValue | Only '{first_argument}' or '{second_argument}' is allowed, not both.
 114 | InputStringIsBlank | {argument} cannot be blank.
 115 | EmptyPublishedFile | Cannot publish empty file: {file_path}
 116 | MissingPublishedFile | File does not exist: {file_path}
 117 | InvalidStreamURL | Invalid LBRY stream URL: '{url}' -- When an URL cannot be downloaded, such as '@Channel/' or a collection
 **2xx** | Configuration | Configuration errors.
 201 | ConfigWrite | Cannot write configuration file '{path}'. -- When writing the default config fails on startup, such as due to permission issues.
 202 | ConfigRead | Cannot find provided configuration file '{path}'. -- Can't open the config file user provided via command line args.
@ -47,14 +52,26 @@ Code | Name | Message
 401 | TransactionRejected | Transaction rejected, unknown reason.
 402 | TransactionFeeTooLow | Fee too low.
 403 | TransactionInvalidSignature | Invalid signature.
-404 | InsufficientFunds |  Insufficient funds. -- determined by wallet prior to attempting to broadcast a tx; this is different for example from a TX being created and sent but then rejected by lbrycrd for unspendable utxos.
+404 | InsufficientFunds |  Not enough funds to cover this transaction. -- determined by wallet prior to attempting to broadcast a tx; this is different for example from a TX being created and sent but then rejected by lbrycrd for unspendable utxos.
 405 | ChannelKeyNotFound | Channel signing key not found.
 406 | ChannelKeyInvalid | Channel signing key is out of date. -- For example, channel was updated but you don't have the updated key.
 407 | DataDownload | Failed to download blob. *generic*
-408 | Resolve | Failed to resolve '{url}'.
+408 | PrivateKeyNotFound | Couldn't find private key for {key} '{value}'.
-409 | ResolveTimeout | Failed to resolve '{url}' within the timeout.
+410 | Resolve | Failed to resolve '{url}'.
-410 | KeyFeeAboveMaxAllowed | {message}
+411 | ResolveTimeout | Failed to resolve '{url}' within the timeout.
-411 | InvalidPassword | Password is invalid.
+411 | ResolveCensored | Resolve of '{url}' was censored by channel with claim id '{censor_id}'.
 420 | KeyFeeAboveMaxAllowed | {message}
 421 | InvalidPassword | Password is invalid.
 422 | IncompatibleWalletServer | '{server}:{port}' has an incompatibly old version.
 423 | TooManyClaimSearchParameters | {key} cant have more than {limit} items.
 424 | AlreadyPurchased | You already have a purchase for claim_id '{claim_id_hex}'. Use --allow-duplicate-purchase flag to override.
 431 | ServerPaymentInvalidAddress | Invalid address from wallet server: '{address}' - skipping payment round.
 432 | ServerPaymentWalletLocked | Cannot spend funds with locked wallet, skipping payment round.
 433 | ServerPaymentFeeAboveMaxAllowed | Daily server fee of {daily_fee} exceeds maximum configured of {max_fee} LBC.
 434 | WalletNotLoaded | Wallet {wallet_id} is not loaded.
 435 | WalletAlreadyLoaded | Wallet {wallet_path} is already loaded.
 436 | WalletNotFound | Wallet not found at {wallet_path}.
 437 | WalletAlreadyExists | Wallet {wallet_path} already exists, use `wallet_add` to load it.
 **5xx** | Blob | **Blobs**
 500 | BlobNotFound | Blob not found.
 501 | BlobPermissionDenied | Permission denied to read blob.
--- a/lbry/lbry/error/init.py
+++ b/lbry/lbry/error/init.py
@ -1,4 +1,4 @@
-from .base import BaseError
+from .base import BaseError, claim_id
 class UserInputError(BaseError):
@ -16,18 +16,22 @@ class CommandError(UserInputError):
 class CommandDoesNotExistError(CommandError):
    def __init__(self, command):
        self.command = command
        super().__init__(f"Command '{command}' does not exist.")
 class CommandDeprecatedError(CommandError):
    def __init__(self, command):
        self.command = command
        super().__init__(f"Command '{command}' is deprecated.")
 class CommandInvalidArgumentError(CommandError):
    def __init__(self, argument, command):
        self.argument = argument
        self.command = command
        super().__init__(f"Invalid argument '{argument}' to command '{command}'.")
@ -37,6 +41,7 @@ class CommandTemporarilyUnavailableError(CommandError):
    """
    def __init__(self, command):
        self.command = command
        super().__init__(f"Command '{command}' is temporarily unavailable.")
@ -46,6 +51,7 @@ class CommandPermanentlyUnavailableError(CommandError):
    """
    def __init__(self, command):
        self.command = command
        super().__init__(f"Command '{command}' is permanently unavailable.")
@ -58,15 +64,57 @@ class InputValueError(UserInputError, ValueError):
 class GenericInputValueError(InputValueError):
    def __init__(self, value, argument):
        self.value = value
        self.argument = argument
        super().__init__(f"The value '{value}' for argument '{argument}' is not valid.")
 class InputValueIsNoneError(InputValueError):
    def __init__(self, argument):
        self.argument = argument
        super().__init__(f"None or null is not valid value for argument '{argument}'.")
 class ConflictingInputValueError(InputValueError):
    def __init__(self, first_argument, second_argument):
        self.first_argument = first_argument
        self.second_argument = second_argument
        super().__init__(f"Only '{first_argument}' or '{second_argument}' is allowed, not both.")
 class InputStringIsBlankError(InputValueError):
    def __init__(self, argument):
        self.argument = argument
        super().__init__(f"{argument} cannot be blank.")
 class EmptyPublishedFileError(InputValueError):
    def __init__(self, file_path):
        self.file_path = file_path
        super().__init__(f"Cannot publish empty file: {file_path}")
 class MissingPublishedFileError(InputValueError):
    def __init__(self, file_path):
        self.file_path = file_path
        super().__init__(f"File does not exist: {file_path}")
 class InvalidStreamURLError(InputValueError):
    """
    When an URL cannot be downloaded, such as '@Channel/' or a collection
    """
    def __init__(self, url):
        self.url = url
        super().__init__(f"Invalid LBRY stream URL: '{url}'")
 class ConfigurationError(BaseError):
    """
    Configuration errors.
@ -79,6 +127,7 @@ class ConfigWriteError(ConfigurationError):
    """
    def __init__(self, path):
        self.path = path
        super().__init__(f"Cannot write configuration file '{path}'.")
@ -88,6 +137,7 @@ class ConfigReadError(ConfigurationError):
    """
    def __init__(self, path):
        self.path = path
        super().__init__(f"Cannot find provided configuration file '{path}'.")
@ -97,18 +147,21 @@ class ConfigParseError(ConfigurationError):
    """
    def __init__(self, path):
        self.path = path
        super().__init__(f"Failed to parse the configuration file '{path}'.")
 class ConfigMissingError(ConfigurationError):
    def __init__(self, path):
        self.path = path
        super().__init__(f"Configuration file '{path}' is missing setting that has no default / fallback.")
 class ConfigInvalidError(ConfigurationError):
    def __init__(self, path):
        self.path = path
        super().__init__(f"Configuration file '{path}' has setting with invalid value.")
@ -161,7 +214,7 @@ class InsufficientFundsError(WalletError):
    """
    def __init__(self):
-        super().__init__("Insufficient funds.")
+        super().__init__("Not enough funds to cover this transaction.")
 class ChannelKeyNotFoundError(WalletError):
@ -185,21 +238,41 @@ class DataDownloadError(WalletError):
        super().__init__("Failed to download blob. *generic*")
 class PrivateKeyNotFoundError(WalletError):
    def __init__(self, key, value):
        self.key = key
        self.value = value
        super().__init__(f"Couldn't find private key for {key} '{value}'.")
 class ResolveError(WalletError):
    def __init__(self, url):
        self.url = url
        super().__init__(f"Failed to resolve '{url}'.")
 class ResolveTimeoutError(WalletError):
    def __init__(self, url):
        self.url = url
        super().__init__(f"Failed to resolve '{url}' within the timeout.")
 class ResolveCensoredError(WalletError):
    def __init__(self, url, censor_id, censor_row):
        self.url = url
        self.censor_id = censor_id
        self.censor_row = censor_row
        super().__init__(f"Resolve of '{url}' was censored by channel with claim id '{censor_id}'.")
 class KeyFeeAboveMaxAllowedError(WalletError):
    def __init__(self, message):
        self.message = message
        super().__init__(f"{message}")
@ -209,6 +282,81 @@ class InvalidPasswordError(WalletError):
        super().__init__("Password is invalid.")
 class IncompatibleWalletServerError(WalletError):
    def __init__(self, server, port):
        self.server = server
        self.port = port
        super().__init__(f"'{server}:{port}' has an incompatibly old version.")
 class TooManyClaimSearchParametersError(WalletError):
    def __init__(self, key, limit):
        self.key = key
        self.limit = limit
        super().__init__(f"{key} cant have more than {limit} items.")
 class AlreadyPurchasedError(WalletError):
    """
    allow-duplicate-purchase flag to override.
    """
    def __init__(self, claim_id_hex):
        self.claim_id_hex = claim_id_hex
        super().__init__(f"You already have a purchase for claim_id '{claim_id_hex}'. Use")
 class ServerPaymentInvalidAddressError(WalletError):
    def __init__(self, address):
        self.address = address
        super().__init__(f"Invalid address from wallet server: '{address}' - skipping payment round.")
 class ServerPaymentWalletLockedError(WalletError):
    def __init__(self):
        super().__init__("Cannot spend funds with locked wallet, skipping payment round.")
 class ServerPaymentFeeAboveMaxAllowedError(WalletError):
    def __init__(self, daily_fee, max_fee):
        self.daily_fee = daily_fee
        self.max_fee = max_fee
        super().__init__(f"Daily server fee of {daily_fee} exceeds maximum configured of {max_fee} LBC.")
 class WalletNotLoadedError(WalletError):
    def __init__(self, wallet_id):
        self.wallet_id = wallet_id
        super().__init__(f"Wallet {wallet_id} is not loaded.")
 class WalletAlreadyLoadedError(WalletError):
    def __init__(self, wallet_path):
        self.wallet_path = wallet_path
        super().__init__(f"Wallet {wallet_path} is already loaded.")
 class WalletNotFoundError(WalletError):
    def __init__(self, wallet_path):
        self.wallet_path = wallet_path
        super().__init__(f"Wallet not found at {wallet_path}.")
 class WalletAlreadyExistsError(WalletError):
    def __init__(self, wallet_path):
        self.wallet_path = wallet_path
        super().__init__(f"Wallet {wallet_path} already exists, use `wallet_add` to load it.")
 class BlobError(BaseError):
    """
    **Blobs**
@ -266,30 +414,35 @@ class DownloadCancelledError(BlobError):
 class DownloadSDTimeoutError(BlobError):
    def __init__(self, download):
        self.download = download
        super().__init__(f"Failed to download sd blob {download} within timeout.")
 class DownloadDataTimeoutError(BlobError):
    def __init__(self, download):
        self.download = download
        super().__init__(f"Failed to download data blobs for sd hash {download} within timeout.")
 class InvalidStreamDescriptorError(BlobError):
    def __init__(self, message):
        self.message = message
        super().__init__(f"{message}")
 class InvalidDataError(BlobError):
    def __init__(self, message):
        self.message = message
        super().__init__(f"{message}")
 class InvalidBlobHashError(BlobError):
    def __init__(self, message):
        self.message = message
        super().__init__(f"{message}")
@ -302,12 +455,14 @@ class ComponentError(BaseError):
 class ComponentStartConditionNotMetError(ComponentError):
    def __init__(self, components):
        self.components = components
        super().__init__(f"Unresolved dependencies for: {components}")
 class ComponentsNotStartedError(ComponentError):
    def __init__(self, message):
        self.message = message
        super().__init__(f"{message}")
@ -320,16 +475,20 @@ class CurrencyExchangeError(BaseError):
 class InvalidExchangeRateResponseError(CurrencyExchangeError):
    def __init__(self, source, reason):
        self.source = source
        self.reason = reason
        super().__init__(f"Failed to get exchange rate from {source}: {reason}")
 class CurrencyConversionError(CurrencyExchangeError):
    def __init__(self, message):
        self.message = message
        super().__init__(f"{message}")
 class InvalidCurrencyError(CurrencyExchangeError):
    def __init__(self, currency):
        self.currency = currency
        super().__init__(f"Invalid currency: {currency} is not a supported currency.")
--- a/lbry/error/base.py
+++ b/lbry/error/base.py
@ -0,0 +1,9 @@
 from binascii import hexlify
 def claim_id(claim_hash):
    return hexlify(claim_hash[::-1]).decode()
 class BaseError(Exception):
    pass
--- a/lbry/lbry/error/generate.py
+++ b/lbry/lbry/error/generate.py
@ -13,10 +13,12 @@ class {name}({parents}):{doc}
 """
 INIT = """
-    def __init__({args}):
+    def __init__({args}):{fields}
        super().__init__({format}"{message}")
 """
 FUNCTIONS = ['claim_id']
 class ErrorClass:
@ -50,11 +52,22 @@ class ErrorClass:
    def get_arguments(self):
        args = ['self']
-        for arg in re.findall('{([a-z0-1]+)}', self.message):
+        for arg in re.findall('{([a-z0-1_()]+)}', self.message):
            for func in FUNCTIONS:
                if arg.startswith(f'{func}('):
                    arg = arg[len(f'{func}('):-1]
                    break
            args.append(arg)
        return args
-    def get_doc_string(self, doc):
+    @staticmethod
    def get_fields(args):
        if len(args) > 1:
            return ''.join(f'\n{INDENT*2}self.{field} = {field}' for field in args[1:])
        return ''
    @staticmethod
    def get_doc_string(doc):
        if doc:
            return f'\n{INDENT}"""\n{indent(fill(doc, 100), INDENT)}\n{INDENT}"""'
        return ""
@ -68,7 +81,8 @@ class ErrorClass:
        args = self.get_arguments()
        if self.is_leaf:
            out.write((CLASS + INIT).format(
-                name=self.class_name, parents=', '.join(parents), args=', '.join(args),
+                name=self.class_name, parents=', '.join(parents),
                args=', '.join(args), fields=self.get_fields(args),
                message=self.message, doc=self.get_doc_string(self.comment), format='f' if len(args) > 1 else ''
            ))
        else:
@ -101,7 +115,7 @@ def find_parent(stack, child):
 def generate(out):
-    out.write('from .base import BaseError\n')
+    out.write(f"from .base import BaseError, {', '.join(FUNCTIONS)}\n")
    stack = {}
    for error in get_errors():
        error.render(out, find_parent(stack, error))
@ -139,7 +153,7 @@ def analyze():
            print(f' - {error}')
-if __name__ == "__main__":
+def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("action", choices=['generate', 'analyze'])
    args = parser.parse_args()
@ -147,3 +161,7 @@ if __name__ == "__main__":
        analyze()
    elif args.action == "generate":
        generate(sys.stdout)
 if __name__ == "__main__":
    main()
--- a/lbry/lbry/extras/daemon/init.py
+++ b/lbry/lbry/extras/daemon/init.py
--- a/lbry/lbry/extras/cli.py
+++ b/lbry/lbry/extras/cli.py
@ -14,9 +14,8 @@ from aiohttp.web import GracefulExit
 from docopt import docopt
 from lbry import __version__ as lbrynet_version
-from lbry.extras.daemon.loggly_handler import get_loggly_handler
+from lbry.extras.daemon.daemon import Daemon
 from lbry.conf import Config, CLIConfig
 from lbry.extras.daemon.Daemon import Daemon
 log = logging.getLogger('lbry')
@ -102,7 +101,7 @@ class ArgumentParser(argparse.ArgumentParser):
        self._optionals.title = 'Options'
        if group_name is None:
            self.epilog = (
-                f"Run 'lbrynet COMMAND --help' for more information on a command or group."
+                "Run 'lbrynet COMMAND --help' for more information on a command or group."
            )
        else:
            self.epilog = (
@ -168,16 +167,16 @@ def add_command_parser(parent, command):
 def get_argument_parser():
-    main = ArgumentParser(
+    root = ArgumentParser(
        'lbrynet', description='An interface to the LBRY Network.', allow_abbrev=False,
    )
-    main.add_argument(
+    root.add_argument(
        '-v', '--version', dest='cli_version', action="store_true",
        help='Show lbrynet CLI version and exit.'
    )
-    main.set_defaults(group=None, command=None)
+    root.set_defaults(group=None, command=None)
-    CLIConfig.contribute_to_argparse(main)
+    CLIConfig.contribute_to_argparse(root)
-    sub = main.add_subparsers(metavar='COMMAND')
+    sub = root.add_subparsers(metavar='COMMAND')
    start = sub.add_parser(
        'start',
        usage='lbrynet start [--config FILE] [--data-dir DIR] [--wallet-dir DIR] [--download-dir DIR] ...',
@ -187,6 +186,10 @@ def get_argument_parser():
        '--quiet', dest='quiet', action="store_true",
        help='Disable all console output.'
    )
    start.add_argument(
        '--no-logging', dest='no_logging', action="store_true",
        help='Disable all logging of any kind.'
    )
    start.add_argument(
        '--verbose', nargs="*",
        help=('Enable debug output for lbry logger and event loop. Optionally specify loggers for which debug output '
@ -217,15 +220,18 @@ def get_argument_parser():
        else:
            add_command_parser(groups[command['group']], command)
-    return main
+    return root
 def ensure_directory_exists(path: str):
    if not os.path.isdir(path):
        pathlib.Path(path).mkdir(parents=True, exist_ok=True)
    use_effective_ids = os.access in os.supports_effective_ids
    if not os.access(path, os.W_OK, effective_ids=use_effective_ids):
        raise PermissionError(f"The following directory is not writable: {path}")
-LOG_MODULES = ('lbry', 'torba', 'aioupnp')
+LOG_MODULES = 'lbry', 'aioupnp'
 def setup_logging(logger: logging.Logger, args: argparse.Namespace, conf: Config):
@ -241,7 +247,6 @@ def setup_logging(logger: logging.Logger, args: argparse.Namespace, conf: Config
            logger.getChild(module_name).addHandler(handler)
    logger.getChild('lbry').setLevel(logging.INFO)
    logger.getChild('torba').setLevel(logging.INFO)
    logger.getChild('aioupnp').setLevel(logging.WARNING)
    logger.getChild('aiohttp').setLevel(logging.CRITICAL)
@ -252,17 +257,13 @@ def setup_logging(logger: logging.Logger, args: argparse.Namespace, conf: Config
        else:
            logger.getChild('lbry').setLevel(logging.DEBUG)
    if conf.share_usage_data:
        loggly_handler = get_loggly_handler()
        loggly_handler.setLevel(logging.ERROR)
        logger.getChild('lbry').addHandler(loggly_handler)
 def run_daemon(args: argparse.Namespace, conf: Config):
    loop = asyncio.get_event_loop()
    if args.verbose is not None:
        loop.set_debug(True)
-    setup_logging(logging.getLogger(), args, conf)
+    if not args.no_logging:
        setup_logging(logging.getLogger(), args, conf)
    daemon = Daemon(conf)
    def __exit():
--- a/lbry/lbry/extras/daemon/migrator/init.py
+++ b/lbry/lbry/extras/daemon/migrator/init.py
--- a/lbry/lbry/extras/daemon/analytics.py
+++ b/lbry/lbry/extras/daemon/analytics.py
@ -1,8 +1,8 @@
 import asyncio
 import collections
 import logging
 import aiohttp
 import typing
 import aiohttp
 from lbry import utils
 from lbry.conf import Config
 from lbry.extras import system_info
@ -18,6 +18,7 @@ DOWNLOAD_STARTED = 'Download Started'
 DOWNLOAD_ERRORED = 'Download Errored'
 DOWNLOAD_FINISHED = 'Download Finished'
 HEARTBEAT = 'Heartbeat'
 DISK_SPACE = 'Disk Space'
 CLAIM_ACTION = 'Claim Action'  # publish/create/update/abandon
 NEW_CHANNEL = 'New Channel'
 CREDITS_SENT = 'Credits Sent'
@ -66,7 +67,7 @@ def _download_properties(conf: Config, external_ip: str, resolve_duration: float
        "node_rpc_timeout": conf.node_rpc_timeout,
        "peer_connect_timeout": conf.peer_connect_timeout,
        "blob_download_timeout": conf.blob_download_timeout,
-        "use_fixed_peers": len(conf.reflector_servers) > 0,
+        "use_fixed_peers": len(conf.fixed_peers) > 0,
        "fixed_peer_delay": fixed_peer_delay,
        "added_fixed_peers": added_fixed_peers,
        "active_peer_count": active_peer_count,
@ -110,7 +111,6 @@ class AnalyticsManager:
        self.cookies = {}
        self.url = ANALYTICS_ENDPOINT
        self._write_key = utils.deobfuscate(ANALYTICS_TOKEN)
        self._enabled = conf.share_usage_data
        self._tracked_data = collections.defaultdict(list)
        self.context = _make_context(system_info.get_platform())
        self.installation_id = installation_id
@ -118,20 +118,24 @@ class AnalyticsManager:
        self.task: typing.Optional[asyncio.Task] = None
        self.external_ip: typing.Optional[str] = None
    @property
    def enabled(self):
        return self.conf.share_usage_data
    @property
    def is_started(self):
        return self.task is not None
    async def start(self):
-        if self._enabled and self.task is None:
+        if self.task is None:
            self.external_ip = await utils.get_external_ip()
            self.task = asyncio.create_task(self.run())
    async def run(self):
        while True:
-            await self._send_heartbeat()
+            if self.enabled:
                self.external_ip, _ = await utils.get_external_ip(self.conf.lbryum_servers)
                await self._send_heartbeat()
            await asyncio.sleep(1800)
            self.external_ip = await utils.get_external_ip()
    def stop(self):
        if self.task is not None and not self.task.done():
@ -154,7 +158,7 @@ class AnalyticsManager:
    async def track(self, event: typing.Dict):
        """Send a single tracking event"""
-        if self._enabled:
+        if self.enabled:
            log.debug('Sending track event: %s', event)
            await self._post(event)
@ -166,6 +170,15 @@ class AnalyticsManager:
            })
        )
    async def send_disk_space_used(self, storage_used, storage_limit, is_from_network_quota):
        await self.track(
            self._event(DISK_SPACE, {
                'used': storage_used,
                'limit': storage_limit,
                'from_network_quota': is_from_network_quota
            })
        )
    async def send_server_startup(self):
        await self.track(self._event(SERVER_STARTUP))
--- a/lbry/lbry/extras/daemon/client.py
+++ b/lbry/lbry/extras/daemon/client.py
@ -1,5 +1,5 @@
 from lbry.conf import Config
 from lbry.extras.cli import execute_command
 from lbry.conf import Config
 def daemon_rpc(conf: Config, method: str, **kwargs):
--- a/lbry/lbry/extras/daemon/Component.py
+++ b/lbry/lbry/extras/daemon/Component.py
@ -1,7 +1,7 @@
 import asyncio
 import logging
 from lbry.conf import Config
-from lbry.extras.daemon.ComponentManager import ComponentManager
+from lbry.extras.daemon.componentmanager import ComponentManager
 log = logging.getLogger(__name__)
@ -37,7 +37,7 @@ class Component(metaclass=ComponentType):
    def running(self):
        return self._running
-    async def get_status(self):
+    async def get_status(self): # pylint: disable=no-self-use
        return
    async def start(self):
--- a/lbry/lbry/extras/daemon/ComponentManager.py
+++ b/lbry/lbry/extras/daemon/ComponentManager.py
@ -42,7 +42,7 @@ class ComponentManager:
        self.analytics_manager = analytics_manager
        self.component_classes = {}
        self.components = set()
-        self.started = asyncio.Event(loop=self.loop)
+        self.started = asyncio.Event()
        self.peer_manager = peer_manager or PeerManager(asyncio.get_event_loop_policy().get_event_loop())
        for component_name, component_class in self.default_component_classes.items():
@ -118,7 +118,7 @@ class ComponentManager:
                component._setup() for component in stage if not component.running
            ]
            if needing_start:
-                await asyncio.wait(needing_start)
+                await asyncio.wait(map(asyncio.create_task, needing_start))
        self.started.set()
    async def stop(self):
@ -131,7 +131,7 @@ class ComponentManager:
                component._stop() for component in stage if component.running
            ]
            if needing_stop:
-                await asyncio.wait(needing_stop)
+                await asyncio.wait(map(asyncio.create_task, needing_stop))
    def all_components_running(self, *component_names):
        """
@ -158,11 +158,14 @@ class ComponentManager:
            for component in self.components
        }
-    def get_component(self, component_name):
+    def get_actual_component(self, component_name):
        for component in self.components:
            if component.component_name == component_name:
-                return component.component
+                return component
        raise NameError(component_name)
    def get_component(self, component_name):
        return self.get_actual_component(component_name).component
    def has_component(self, component_name):
        return any(component for component in self.components if component_name == component.component_name)
--- a/lbry/lbry/extras/daemon/Components.py
+++ b/lbry/lbry/extras/daemon/Components.py
@ -4,6 +4,7 @@ import asyncio
 import logging
 import binascii
 import typing
 import base58
 from aioupnp import __version__ as aioupnp_version
@ -15,12 +16,19 @@ from lbry.dht.node import Node
 from lbry.dht.peer import is_valid_public_ipv4
 from lbry.dht.blob_announcer import BlobAnnouncer
 from lbry.blob.blob_manager import BlobManager
 from lbry.blob.disk_space_manager import DiskSpaceManager
 from lbry.blob_exchange.server import BlobServer
 from lbry.stream.background_downloader import BackgroundDownloader
 from lbry.stream.stream_manager import StreamManager
-from lbry.extras.daemon.Component import Component
+from lbry.file.file_manager import FileManager
 from lbry.extras.daemon.component import Component
 from lbry.extras.daemon.exchange_rate_manager import ExchangeRateManager
 from lbry.extras.daemon.storage import SQLiteStorage
-from lbry.wallet import LbryWalletManager
+from lbry.torrent.torrent_manager import TorrentManager
 from lbry.wallet import WalletManager
 from lbry.wallet.usage_payment import WalletServerPayer
 from lbry.torrent.tracker import TrackerClient
 from lbry.torrent.session import TorrentSession
 log = logging.getLogger(__name__)
@ -29,12 +37,17 @@ log = logging.getLogger(__name__)
 DATABASE_COMPONENT = "database"
 BLOB_COMPONENT = "blob_manager"
 WALLET_COMPONENT = "wallet"
 WALLET_SERVER_PAYMENTS_COMPONENT = "wallet_server_payments"
 DHT_COMPONENT = "dht"
 HASH_ANNOUNCER_COMPONENT = "hash_announcer"
-STREAM_MANAGER_COMPONENT = "stream_manager"
+FILE_MANAGER_COMPONENT = "file_manager"
 DISK_SPACE_COMPONENT = "disk_space"
 BACKGROUND_DOWNLOADER_COMPONENT = "background_downloader"
 PEER_PROTOCOL_SERVER_COMPONENT = "peer_protocol_server"
 UPNP_COMPONENT = "upnp"
 EXCHANGE_RATE_MANAGER_COMPONENT = "exchange_rate_manager"
 TRACKER_ANNOUNCER_COMPONENT = "tracker_announcer_component"
 LIBTORRENT_COMPONENT = "libtorrent_component"
 class DatabaseComponent(Component):
@ -50,7 +63,7 @@ class DatabaseComponent(Component):
    @staticmethod
    def get_current_db_revision():
-        return 14
+        return 15
    @property
    def revision_filename(self):
@ -110,9 +123,17 @@ class WalletComponent(Component):
    async def get_status(self):
        if self.wallet_manager is None:
            return
-        session_pool = self.wallet_manager.ledger.network.session_pool
+        is_connected = self.wallet_manager.ledger.network.is_connected
-        sessions = session_pool.sessions
+        sessions = []
        connected = None
        if is_connected:
            addr, port = self.wallet_manager.ledger.network.client.server
            connected = f"{addr}:{port}"
            sessions.append(self.wallet_manager.ledger.network.client)
        result = {
            'connected': connected,
            'connected_features': self.wallet_manager.ledger.network.server_features,
            'servers': [
                {
                    'host': session.server[0],
@ -121,18 +142,20 @@ class WalletComponent(Component):
                    'availability': session.available,
                } for session in sessions
            ],
-            'known_servers': len(sessions),
+            'known_servers': len(self.wallet_manager.ledger.network.known_hubs),
-            'available_servers': len(list(session_pool.available_sessions))
+            'available_servers': 1 if is_connected else 0
        }
        if self.wallet_manager.ledger.network.remote_height:
            local_height = self.wallet_manager.ledger.local_height_including_downloaded_height
            disk_height = len(self.wallet_manager.ledger.headers)
            download_height = local_height - disk_height if disk_height != local_height else local_height
            remote_height = self.wallet_manager.ledger.network.remote_height
-            target_height = remote_height - disk_height if disk_height != local_height else remote_height
+            download_height, target_height = local_height - disk_height, remote_height - disk_height
-            best_hash = self.wallet_manager.get_best_blockhash()
+            if target_height > 0:
-            progress = min(max(math.ceil(float(download_height) / float(target_height) * 100), 0), 100)
+                progress = min(max(math.ceil(float(download_height) / float(target_height) * 100), 0), 100)
            else:
                progress = 100
            best_hash = await self.wallet_manager.get_best_blockhash()
            result.update({
                'headers_synchronization_progress': progress,
                'blocks': max(local_height, 0),
@ -143,8 +166,8 @@ class WalletComponent(Component):
        return result
    async def start(self):
-        log.info("Starting torba wallet")
+        log.info("Starting wallet")
-        self.wallet_manager = await LbryWalletManager.from_lbrynet_config(self.conf)
+        self.wallet_manager = await WalletManager.from_lbrynet_config(self.conf)
        await self.wallet_manager.start()
    async def stop(self):
@ -152,6 +175,34 @@ class WalletComponent(Component):
        self.wallet_manager = None
 class WalletServerPaymentsComponent(Component):
    component_name = WALLET_SERVER_PAYMENTS_COMPONENT
    depends_on = [WALLET_COMPONENT]
    def __init__(self, component_manager):
        super().__init__(component_manager)
        self.usage_payment_service = WalletServerPayer(
            max_fee=self.conf.max_wallet_server_fee, analytics_manager=self.component_manager.analytics_manager,
        )
    @property
    def component(self) -> typing.Optional[WalletServerPayer]:
        return self.usage_payment_service
    async def start(self):
        wallet_manager = self.component_manager.get_component(WALLET_COMPONENT)
        await self.usage_payment_service.start(wallet_manager.ledger, wallet_manager.default_wallet)
    async def stop(self):
        await self.usage_payment_service.stop()
    async def get_status(self):
        return {
            'max_fee': self.usage_payment_service.max_fee,
            'running': self.usage_payment_service.running
        }
 class BlobComponent(Component):
    component_name = BLOB_COMPONENT
    depends_on = [DATABASE_COMPONENT]
@ -228,7 +279,7 @@ class DHTComponent(Component):
        external_ip = upnp_component.external_ip
        storage = self.component_manager.get_component(DATABASE_COMPONENT)
        if not external_ip:
-            external_ip = await utils.get_external_ip()
+            external_ip, _ = await utils.get_external_ip(self.conf.lbryum_servers)
            if not external_ip:
                log.warning("failed to get external ip")
@ -242,6 +293,7 @@ class DHTComponent(Component):
            peer_port=self.external_peer_port,
            rpc_timeout=self.conf.node_rpc_timeout,
            split_buckets_under_index=self.conf.split_buckets_under_index,
            is_bootstrap_node=self.conf.is_bootstrap_node,
            storage=storage
        )
        self.dht_node.start(self.conf.network_interface, self.conf.known_dht_nodes)
@ -280,23 +332,23 @@ class HashAnnouncerComponent(Component):
        }
-class StreamManagerComponent(Component):
+class FileManagerComponent(Component):
-    component_name = STREAM_MANAGER_COMPONENT
+    component_name = FILE_MANAGER_COMPONENT
    depends_on = [BLOB_COMPONENT, DATABASE_COMPONENT, WALLET_COMPONENT]
    def __init__(self, component_manager):
        super().__init__(component_manager)
-        self.stream_manager: typing.Optional[StreamManager] = None
+        self.file_manager: typing.Optional[FileManager] = None
    @property
-    def component(self) -> typing.Optional[StreamManager]:
+    def component(self) -> typing.Optional[FileManager]:
-        return self.stream_manager
+        return self.file_manager
    async def get_status(self):
-        if not self.stream_manager:
+        if not self.file_manager:
            return
        return {
-            'managed_files': len(self.stream_manager.streams),
+            'managed_files': len(self.file_manager.get_filtered()),
        }
    async def start(self):
@ -307,14 +359,148 @@ class StreamManagerComponent(Component):
            if self.component_manager.has_component(DHT_COMPONENT) else None
        log.info('Starting the file manager')
        loop = asyncio.get_event_loop()
-        self.stream_manager = StreamManager(
+        self.file_manager = FileManager(
-            loop, self.conf, blob_manager, wallet, storage, node, self.component_manager.analytics_manager
+            loop, self.conf, wallet, storage, self.component_manager.analytics_manager
        )
-        await self.stream_manager.start()
+        self.file_manager.source_managers['stream'] = StreamManager(
            loop, self.conf, blob_manager, wallet, storage, node,
        )
        if self.component_manager.has_component(LIBTORRENT_COMPONENT):
            torrent = self.component_manager.get_component(LIBTORRENT_COMPONENT)
            self.file_manager.source_managers['torrent'] = TorrentManager(
                loop, self.conf, torrent, storage, self.component_manager.analytics_manager
            )
        await self.file_manager.start()
        log.info('Done setting up file manager')
    async def stop(self):
-        self.stream_manager.stop()
+        await self.file_manager.stop()
 class BackgroundDownloaderComponent(Component):
    MIN_PREFIX_COLLIDING_BITS = 8
    component_name = BACKGROUND_DOWNLOADER_COMPONENT
    depends_on = [DATABASE_COMPONENT, BLOB_COMPONENT, DISK_SPACE_COMPONENT]
    def __init__(self, component_manager):
        super().__init__(component_manager)
        self.background_task: typing.Optional[asyncio.Task] = None
        self.download_loop_delay_seconds = 60
        self.ongoing_download: typing.Optional[asyncio.Task] = None
        self.space_manager: typing.Optional[DiskSpaceManager] = None
        self.blob_manager: typing.Optional[BlobManager] = None
        self.background_downloader: typing.Optional[BackgroundDownloader] = None
        self.dht_node: typing.Optional[Node] = None
        self.space_available: typing.Optional[int] = None
    @property
    def is_busy(self):
        return bool(self.ongoing_download and not self.ongoing_download.done())
    @property
    def component(self) -> 'BackgroundDownloaderComponent':
        return self
    async def get_status(self):
        return {'running': self.background_task is not None and not self.background_task.done(),
                'available_free_space_mb': self.space_available,
                'ongoing_download': self.is_busy}
    async def download_blobs_in_background(self):
        while True:
            self.space_available = await self.space_manager.get_free_space_mb(True)
            if not self.is_busy and self.space_available > 10:
                self._download_next_close_blob_hash()
            await asyncio.sleep(self.download_loop_delay_seconds)
    def _download_next_close_blob_hash(self):
        node_id = self.dht_node.protocol.node_id
        for blob_hash in self.dht_node.stored_blob_hashes:
            if blob_hash.hex() in self.blob_manager.completed_blob_hashes:
                continue
            if utils.get_colliding_prefix_bits(node_id, blob_hash) >= self.MIN_PREFIX_COLLIDING_BITS:
                self.ongoing_download = asyncio.create_task(self.background_downloader.download_blobs(blob_hash.hex()))
                return
    async def start(self):
        self.space_manager: DiskSpaceManager = self.component_manager.get_component(DISK_SPACE_COMPONENT)
        if not self.component_manager.has_component(DHT_COMPONENT):
            return
        self.dht_node = self.component_manager.get_component(DHT_COMPONENT)
        self.blob_manager = self.component_manager.get_component(BLOB_COMPONENT)
        storage = self.component_manager.get_component(DATABASE_COMPONENT)
        self.background_downloader = BackgroundDownloader(self.conf, storage, self.blob_manager, self.dht_node)
        self.background_task = asyncio.create_task(self.download_blobs_in_background())
    async def stop(self):
        if self.ongoing_download and not self.ongoing_download.done():
            self.ongoing_download.cancel()
        if self.background_task:
            self.background_task.cancel()
 class DiskSpaceComponent(Component):
    component_name = DISK_SPACE_COMPONENT
    depends_on = [DATABASE_COMPONENT, BLOB_COMPONENT]
    def __init__(self, component_manager):
        super().__init__(component_manager)
        self.disk_space_manager: typing.Optional[DiskSpaceManager] = None
    @property
    def component(self) -> typing.Optional[DiskSpaceManager]:
        return self.disk_space_manager
    async def get_status(self):
        if self.disk_space_manager:
            space_used = await self.disk_space_manager.get_space_used_mb(cached=True)
            return {
                'total_used_mb': space_used['total'],
                'published_blobs_storage_used_mb': space_used['private_storage'],
                'content_blobs_storage_used_mb': space_used['content_storage'],
                'seed_blobs_storage_used_mb': space_used['network_storage'],
                'running': self.disk_space_manager.running,
            }
        return {'space_used': '0', 'network_seeding_space_used': '0', 'running': False}
    async def start(self):
        db = self.component_manager.get_component(DATABASE_COMPONENT)
        blob_manager = self.component_manager.get_component(BLOB_COMPONENT)
        self.disk_space_manager = DiskSpaceManager(
            self.conf, db, blob_manager,
            analytics=self.component_manager.analytics_manager
        )
        await self.disk_space_manager.start()
    async def stop(self):
        await self.disk_space_manager.stop()
 class TorrentComponent(Component):
    component_name = LIBTORRENT_COMPONENT
    def __init__(self, component_manager):
        super().__init__(component_manager)
        self.torrent_session = None
    @property
    def component(self) -> typing.Optional[TorrentSession]:
        return self.torrent_session
    async def get_status(self):
        if not self.torrent_session:
            return
        return {
            'running': True,  # TODO: what to return here?
        }
    async def start(self):
        self.torrent_session = TorrentSession(asyncio.get_event_loop(), None)
        await self.torrent_session.bind()  # TODO: specify host/port
    async def stop(self):
        if self.torrent_session:
            await self.torrent_session.pause()
 class PeerProtocolServerComponent(Component):
@ -331,9 +517,8 @@ class PeerProtocolServerComponent(Component):
    async def start(self):
        log.info("start blob server")
        upnp = self.component_manager.get_component(UPNP_COMPONENT)
        blob_manager: BlobManager = self.component_manager.get_component(BLOB_COMPONENT)
-        wallet: LbryWalletManager = self.component_manager.get_component(WALLET_COMPONENT)
+        wallet: WalletManager = self.component_manager.get_component(WALLET_COMPONENT)
        peer_port = self.conf.tcp_port
        address = await wallet.get_unused_address()
        self.blob_server = BlobServer(asyncio.get_event_loop(), blob_manager, address)
@ -366,7 +551,7 @@ class UPnPComponent(Component):
        while True:
            if now:
                await self._maintain_redirects()
-            await asyncio.sleep(360, loop=self.component_manager.loop)
+            await asyncio.sleep(360)
    async def _maintain_redirects(self):
        # setup the gateway if necessary
@ -375,8 +560,6 @@ class UPnPComponent(Component):
                self.upnp = await UPnP.discover(loop=self.component_manager.loop)
                log.info("found upnp gateway: %s", self.upnp.gateway.manufacturer_string)
            except Exception as err:
                if isinstance(err, asyncio.CancelledError):
                    raise
                log.warning("upnp discovery failed: %s", err)
                self.upnp = None
@ -391,11 +574,15 @@ class UPnPComponent(Component):
                pass
        if external_ip and not is_valid_public_ipv4(external_ip):
            log.warning("UPnP returned a private/reserved ip - %s, checking lbry.com fallback", external_ip)
-            external_ip = await utils.get_external_ip()
+            external_ip, _ = await utils.get_external_ip(self.conf.lbryum_servers)
        if self.external_ip and self.external_ip != external_ip:
            log.info("external ip changed from %s to %s", self.external_ip, external_ip)
        if external_ip:
            self.external_ip = external_ip
            dht_component = self.component_manager.get_component(DHT_COMPONENT)
            if dht_component:
                dht_node = dht_component.component
                dht_node.protocol.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
@ -440,22 +627,24 @@ class UPnPComponent(Component):
                    log.info("refreshed upnp redirect for peer port: %i", tcp_port)
                except (asyncio.TimeoutError, UPnPError, NotImplementedError):
                    del self.upnp_redirects['TCP']
-            if ('TCP' in self.upnp_redirects
+            if ('TCP' in self.upnp_redirects and
-                and PEER_PROTOCOL_SERVER_COMPONENT not in self.component_manager.skip_components) 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):
+                    ('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")
    async def start(self):
        log.info("detecting external ip")
        if not self.use_upnp:
-            self.external_ip = await utils.get_external_ip()
+            self.external_ip, _ = await utils.get_external_ip(self.conf.lbryum_servers)
            return
        success = False
        await self._maintain_redirects()
        if self.upnp:
-            if not self.upnp_redirects and not all([x in self.component_manager.skip_components for x in
+            if not self.upnp_redirects and not all(
-                                                    (DHT_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT)]):
+                    x in self.component_manager.skip_components
                    for x in (DHT_COMPONENT, PEER_PROTOCOL_SERVER_COMPONENT)
            ):
                log.error("failed to setup upnp")
            else:
                success = True
@ -464,12 +653,14 @@ class UPnPComponent(Component):
        else:
            log.error("failed to setup upnp")
        if not self.external_ip:
-            self.external_ip = await utils.get_external_ip()
+            self.external_ip, probed_url = await utils.get_external_ip(self.conf.lbryum_servers)
            if self.external_ip:
-                log.info("detected external ip using lbry.com fallback")
+                log.info("detected external ip using %s fallback", probed_url)
        if self.component_manager.analytics_manager:
-            await self.component_manager.analytics_manager.send_upnp_setup_success_fail(
+            self.component_manager.loop.create_task(
-                success, await self.get_status()
+                self.component_manager.analytics_manager.send_upnp_setup_success_fail(
                    success, await self.get_status()
                )
            )
        self._maintain_redirects_task = self.component_manager.loop.create_task(
            self._repeatedly_maintain_redirects(now=False)
@ -480,7 +671,7 @@ class UPnPComponent(Component):
            log.info("Removing upnp redirects: %s", self.upnp_redirects)
            await asyncio.wait([
                self.upnp.delete_port_mapping(port, protocol) for protocol, port in self.upnp_redirects.items()
-            ], loop=self.component_manager.loop)
+            ])
        if self._maintain_redirects_task and not self._maintain_redirects_task.done():
            self._maintain_redirects_task.cancel()
@ -511,3 +702,49 @@ class ExchangeRateManagerComponent(Component):
    async def stop(self):
        self.exchange_rate_manager.stop()
 class TrackerAnnouncerComponent(Component):
    component_name = TRACKER_ANNOUNCER_COMPONENT
    depends_on = [FILE_MANAGER_COMPONENT]
    def __init__(self, component_manager):
        super().__init__(component_manager)
        self.file_manager = None
        self.announce_task = None
        self.tracker_client: typing.Optional[TrackerClient] = None
    @property
    def component(self):
        return self.tracker_client
    @property
    def running(self):
        return self._running and self.announce_task and not self.announce_task.done()
    async def announce_forever(self):
        while True:
            sleep_seconds = 60.0
            announce_sd_hashes = []
            for file in self.file_manager.get_filtered():
                if not file.downloader:
                    continue
                announce_sd_hashes.append(bytes.fromhex(file.sd_hash))
            await self.tracker_client.announce_many(*announce_sd_hashes)
            await asyncio.sleep(sleep_seconds)
    async def start(self):
        node = self.component_manager.get_component(DHT_COMPONENT) \
            if self.component_manager.has_component(DHT_COMPONENT) else None
        node_id = node.protocol.node_id if node else None
        self.tracker_client = TrackerClient(node_id, self.conf.tcp_port, lambda: self.conf.tracker_servers)
        await self.tracker_client.start()
        self.file_manager = self.component_manager.get_component(FILE_MANAGER_COMPONENT)
        self.announce_task = asyncio.create_task(self.announce_forever())
    async def stop(self):
        self.file_manager = None
        if self.announce_task and not self.announce_task.done():
            self.announce_task.cancel()
        self.announce_task = None
        self.tracker_client.stop()
--- a/lbry/lbry/extras/daemon/Daemon.py
+++ b/lbry/lbry/extras/daemon/Daemon.py
--- a/lbry/lbry/extras/daemon/exchange_rate_manager.py
+++ b/lbry/lbry/extras/daemon/exchange_rate_manager.py
@ -2,8 +2,10 @@ import json
 import time
 import asyncio
 import logging
 from statistics import median
 from decimal import Decimal
 from typing import Optional, Iterable, Type
 from aiohttp.client_exceptions import ContentTypeError, ClientConnectionError
 from lbry.error import InvalidExchangeRateResponseError, CurrencyConversionError
 from lbry.utils import aiohttp_request
 from lbry.wallet.dewies import lbc_to_dewies
@ -29,9 +31,9 @@ class ExchangeRate:
 class MarketFeed:
-    name: str
+    name: str = ""
-    market: str
+    market: str = ""
-    url: str
+    url: str = ""
    params = {}
    fee = 0
@ -53,12 +55,20 @@ class MarketFeed:
    def is_online(self):
        return self.last_check+self.update_interval+self.request_timeout > time.time()
-    def get_rate_from_response(self, response):
+    def get_rate_from_response(self, json_response):
        raise NotImplementedError()
    async def get_response(self):
-        async with aiohttp_request('get', self.url, params=self.params, timeout=self.request_timeout) as response:
+        async with aiohttp_request(
-            self._last_response = await response.json()
+                'get', self.url, params=self.params,
                timeout=self.request_timeout, headers={"User-Agent": "lbrynet"}
        ) as response:
            try:
                self._last_response = await response.json(content_type=None)
            except ContentTypeError as e:
                self._last_response = {}
                log.warning("Could not parse exchange rate response from %s: %s", self.name, e.message)
                log.debug(await response.text())
            return self._last_response
    async def get_rate(self):
@ -69,18 +79,21 @@ class MarketFeed:
            log.debug("Saving rate update %f for %s from %s", rate, self.market, self.name)
            self.rate = ExchangeRate(self.market, rate, int(time.time()))
            self.last_check = time.time()
            self.event.set()
            return self.rate
        except asyncio.CancelledError:
            raise
        except asyncio.TimeoutError:
            log.warning("Timed out fetching exchange rate from %s.", self.name)
        except json.JSONDecodeError as e:
-            log.warning("Could not parse exchange rate response from %s: %s", self.name, e.doc)
+            msg = e.doc if '<html>' not in e.doc else 'unexpected content type.'
            log.warning("Could not parse exchange rate response from %s: %s", self.name, msg)
            log.debug(e.doc)
        except InvalidExchangeRateResponseError as e:
            log.warning(str(e))
        except ClientConnectionError as e:
            log.warning("Error trying to connect to exchange rate %s: %s", self.name, str(e))
        except Exception as e:
            log.exception("Exchange rate error (%s from %s):", self.market, self.name)
        finally:
            self.event.set()
    async def keep_updated(self):
        while True:
@ -98,70 +111,92 @@ class MarketFeed:
        self.event.clear()
-class BittrexFeed(MarketFeed):
+class BaseBittrexFeed(MarketFeed):
    name = "Bittrex"
-    market = "BTCLBC"
+    market = None
-    url = "https://bittrex.com/api/v1.1/public/getmarkethistory"
+    url = None
    params = {'market': 'BTC-LBC', 'count': 50}
    fee = 0.0025
    def get_rate_from_response(self, json_response):
        if 'lastTradeRate' not in json_response:
            raise InvalidExchangeRateResponseError(self.name, 'result not found')
        return 1.0 / float(json_response['lastTradeRate'])
 class BittrexBTCFeed(BaseBittrexFeed):
    market = "BTCLBC"
    url = "https://api.bittrex.com/v3/markets/LBC-BTC/ticker"
 class BittrexUSDFeed(BaseBittrexFeed):
    market = "USDLBC"
    url = "https://api.bittrex.com/v3/markets/LBC-USD/ticker"
 class BaseCoinExFeed(MarketFeed):
    name = "CoinEx"
    market = None
    url = None
    def get_rate_from_response(self, json_response):
        if 'data' not in json_response or \
           'ticker' not in json_response['data'] or \
           'last' not in json_response['data']['ticker']:
            raise InvalidExchangeRateResponseError(self.name, 'result not found')
        return 1.0 / float(json_response['data']['ticker']['last'])
 class CoinExBTCFeed(BaseCoinExFeed):
    market = "BTCLBC"
    url = "https://api.coinex.com/v1/market/ticker?market=LBCBTC"
 class CoinExUSDFeed(BaseCoinExFeed):
    market = "USDLBC"
    url = "https://api.coinex.com/v1/market/ticker?market=LBCUSDT"
 class BaseHotbitFeed(MarketFeed):
    name = "hotbit"
    market = None
    url = "https://api.hotbit.io/api/v1/market.last"
    def get_rate_from_response(self, json_response):
        if 'result' not in json_response:
            raise InvalidExchangeRateResponseError(self.name, 'result not found')
-        trades = json_response['result']
+        return 1.0 / float(json_response['result'])
        if len(trades) == 0:
            raise InvalidExchangeRateResponseError(self.name, 'trades not found')
        totals = sum([i['Total'] for i in trades])
        qtys = sum([i['Quantity'] for i in trades])
        if totals <= 0 or qtys <= 0:
            raise InvalidExchangeRateResponseError(self.name, 'quantities were not positive')
        vwap = totals / qtys
        return float(1.0 / vwap)
-class LBRYFeed(MarketFeed):
+class HotbitBTCFeed(BaseHotbitFeed):
    name = "lbry.com"
    market = "BTCLBC"
-    url = "https://api.lbry.com/lbc/exchange_rate"
+    params = {"market": "LBC/BTC"}
    def get_rate_from_response(self, json_response):
        if 'data' not in json_response:
            raise InvalidExchangeRateResponseError(self.name, 'result not found')
        return 1.0 / json_response['data']['lbc_btc']
-class LBRYBTCFeed(LBRYFeed):
+class HotbitUSDFeed(BaseHotbitFeed):
-    market = "USDBTC"
+    market = "USDLBC"
-
+    params = {"market": "LBC/USDT"}
    def get_rate_from_response(self, json_response):
        if 'data' not in json_response:
            raise InvalidExchangeRateResponseError(self.name, 'result not found')
        return 1.0 / json_response['data']['btc_usd']
-class CryptonatorFeed(MarketFeed):
+class UPbitBTCFeed(MarketFeed):
-    name = "cryptonator.com"
+    name = "UPbit"
    market = "BTCLBC"
-    url = "https://api.cryptonator.com/api/ticker/btc-lbc"
+    url = "https://api.upbit.com/v1/ticker"
    params = {"markets": "BTC-LBC"}
    def get_rate_from_response(self, json_response):
-        if 'ticker' not in json_response or len(json_response['ticker']) == 0 or \
+        if "error" in json_response or len(json_response) != 1 or 'trade_price' not in json_response[0]:
                'success' not in json_response or json_response['success'] is not True:
            raise InvalidExchangeRateResponseError(self.name, 'result not found')
-        return float(json_response['ticker']['price'])
+        return 1.0 / float(json_response[0]['trade_price'])
 class CryptonatorBTCFeed(CryptonatorFeed):
    market = "USDBTC"
    url = "https://api.cryptonator.com/api/ticker/usd-btc"
 FEEDS: Iterable[Type[MarketFeed]] = (
-    LBRYFeed,
+    BittrexBTCFeed,
-    LBRYBTCFeed,
+    BittrexUSDFeed,
-    BittrexFeed,
+    CoinExBTCFeed,
-    CryptonatorFeed,
+    CoinExUSDFeed,
-    CryptonatorBTCFeed,
+#    HotbitBTCFeed,
 #    HotbitUSDFeed,
 #    UPbitBTCFeed,
 )
@ -185,20 +220,23 @@ class ExchangeRateManager:
            source.stop()
    def convert_currency(self, from_currency, to_currency, amount):
-        rates = [market.rate for market in self.market_feeds]
+        log.debug(
-        log.debug("Converting %f %s to %s, rates: %s" % (amount, from_currency, to_currency, rates))
+            "Converting %f %s to %s, rates: %s",
            amount, from_currency, to_currency,
            [market.rate for market in self.market_feeds]
        )
        if from_currency == to_currency:
            return round(amount, 8)
        rates = []
        for market in self.market_feeds:
            if (market.has_rate and market.is_online and
                    market.rate.currency_pair == (from_currency, to_currency)):
-                return round(amount * Decimal(market.rate.spot), 8)
+                rates.append(market.rate.spot)
-        for market in self.market_feeds:
+
-            if (market.has_rate and market.is_online and
+        if rates:
-                    market.rate.currency_pair[0] == from_currency):
+            return round(amount * Decimal(median(rates)), 8)
-                return round(self.convert_currency(
+
                    market.rate.currency_pair[1], to_currency, amount * Decimal(market.rate.spot)), 8)
        raise CurrencyConversionError(
            f'Unable to convert {amount} from {from_currency} to {to_currency}')
--- a/lbry/lbry/extras/daemon/json_response_encoder.py
+++ b/lbry/lbry/extras/daemon/json_response_encoder.py
@ -6,11 +6,11 @@ from json import JSONEncoder
 from google.protobuf.message import DecodeError
 from torba.client.wallet import Wallet
 from torba.client.bip32 import PubKey
 from lbry.schema.claim import Claim
-from lbry.wallet.ledger import MainNetLedger, Account
+from lbry.schema.support import Support
-from lbry.wallet.transaction import Transaction, Output
+from lbry.torrent.torrent_manager import TorrentSource
 from lbry.wallet import Wallet, Ledger, Account, Transaction, Output
 from lbry.wallet.bip32 import PublicKey
 from lbry.wallet.dewies import dewies_to_lbc
 from lbry.stream.managed_stream import ManagedStream
@ -27,6 +27,8 @@ def encode_txo_doc():
        'address': "address of who can spend the txo",
        'confirmations': "number of confirmed blocks",
        'is_change': "payment to change address, only available when it can be determined",
        'is_received': "true if txo was sent from external account to this account",
        'is_spent': "true if txo is spent",
        'is_mine': "payment to one of your accounts, only available when it can be determined",
        'type': "one of 'claim', 'support' or 'purchase'",
        'name': "when type is 'claim' or 'support', this is the claim name",
@ -108,23 +110,25 @@ def encode_file_doc():
        'metadata': '(dict) None if claim is not found else the claim metadata',
        'channel_claim_id': '(str) None if claim is not found or not signed',
        'channel_name': '(str) None if claim is not found or not signed',
-        'claim_name': '(str) None if claim is not found else the claim name'
+        'claim_name': '(str) None if claim is not found else the claim name',
        'reflector_progress': '(int) reflector upload progress, 0 to 100',
        'uploading_to_reflector': '(bool) set to True when currently uploading to reflector'
    }
 class JSONResponseEncoder(JSONEncoder):
-    def __init__(self, *args, ledger: MainNetLedger, include_protobuf=False, **kwargs):
+    def __init__(self, *args, ledger: Ledger, include_protobuf=False, **kwargs):
        super().__init__(*args, **kwargs)
        self.ledger = ledger
        self.include_protobuf = include_protobuf
-    def default(self, obj):  # pylint: disable=method-hidden
+    def default(self, obj):  # pylint: disable=method-hidden,arguments-renamed,too-many-return-statements
        if isinstance(obj, Account):
            return self.encode_account(obj)
        if isinstance(obj, Wallet):
            return self.encode_wallet(obj)
-        if isinstance(obj, ManagedStream):
+        if isinstance(obj, (ManagedStream, TorrentSource)):
            return self.encode_file(obj)
        if isinstance(obj, Transaction):
            return self.encode_transaction(obj)
@ -132,7 +136,9 @@ class JSONResponseEncoder(JSONEncoder):
            return self.encode_output(obj)
        if isinstance(obj, Claim):
            return self.encode_claim(obj)
-        if isinstance(obj, PubKey):
+        if isinstance(obj, Support):
            return obj.to_dict()
        if isinstance(obj, PublicKey):
            return obj.extended_key_string()
        if isinstance(obj, datetime):
            return obj.strftime("%Y%m%dT%H:%M:%S")
@ -166,12 +172,22 @@ class JSONResponseEncoder(JSONEncoder):
            'amount': dewies_to_lbc(txo.amount),
            'address': txo.get_address(self.ledger) if txo.has_address else None,
            'confirmations': (best_height+1) - tx_height if tx_height > 0 else tx_height,
-            'timestamp': self.ledger.headers[tx_height]['timestamp'] if 0 < tx_height <= best_height else None
+            'timestamp': self.ledger.headers.estimated_timestamp(tx_height)
        }
-        if txo.is_change is not None:
+        if txo.is_spent is not None:
-            output['is_change'] = txo.is_change
+            output['is_spent'] = txo.is_spent
-        if txo.is_my_account is not None:
+        if txo.is_my_output is not None:
-            output['is_mine'] = txo.is_my_account
+            output['is_my_output'] = txo.is_my_output
        if txo.is_my_input is not None:
            output['is_my_input'] = txo.is_my_input
        if txo.sent_supports is not None:
            output['sent_supports'] = dewies_to_lbc(txo.sent_supports)
        if txo.sent_tips is not None:
            output['sent_tips'] = dewies_to_lbc(txo.sent_tips)
        if txo.received_tips is not None:
            output['received_tips'] = dewies_to_lbc(txo.received_tips)
        if txo.is_internal_transfer is not None:
            output['is_internal_transfer'] = txo.is_internal_transfer
        if txo.script.is_claim_name:
            output['type'] = 'claim'
@ -207,25 +223,26 @@ class JSONResponseEncoder(JSONEncoder):
                output['claims'] = [self.encode_output(o) for o in txo.claims]
            if txo.reposted_claim is not None:
                output['reposted_claim'] = self.encode_output(txo.reposted_claim)
-            if txo.script.is_claim_name or txo.script.is_update_claim:
+        if txo.script.is_claim_name or txo.script.is_update_claim or txo.script.is_support_claim_data:
-                try:
+            try:
-                    output['value'] = txo.claim
+                output['value'] = txo.signable
                if self.include_protobuf:
                    output['protobuf'] = hexlify(txo.signable.to_bytes())
                if txo.purchase_receipt is not None:
                    output['purchase_receipt'] = self.encode_output(txo.purchase_receipt)
                if txo.script.is_claim_name or txo.script.is_update_claim:
                    output['value_type'] = txo.claim.claim_type
                    if self.include_protobuf:
                        output['protobuf'] = hexlify(txo.claim.to_bytes())
                    if txo.purchase_receipt is not None:
                        output['purchase_receipt'] = self.encode_output(txo.purchase_receipt)
                    if txo.claim.is_channel:
                        output['has_signing_key'] = txo.has_private_key
-                    if check_signature and txo.claim.is_signed:
+                if check_signature and txo.signable.is_signed:
-                        if txo.channel is not None:
+                    if txo.channel is not None:
-                            output['signing_channel'] = self.encode_output(txo.channel)
+                        output['signing_channel'] = self.encode_output(txo.channel)
-                            output['is_channel_signature_valid'] = txo.is_signed_by(txo.channel, self.ledger)
+                        output['is_channel_signature_valid'] = txo.is_signed_by(txo.channel, self.ledger)
-                        else:
+                    else:
-                            output['signing_channel'] = {'channel_id': txo.claim.signing_channel_id}
+                        output['signing_channel'] = {'channel_id': txo.signable.signing_channel_id}
-                            output['is_channel_signature_valid'] = False
+                        output['is_channel_signature_valid'] = False
-                except DecodeError:
+            except DecodeError:
-                    pass
+                pass
        return output
    def encode_claim_meta(self, meta):
@ -234,7 +251,7 @@ class JSONResponseEncoder(JSONEncoder):
                if isinstance(value, int):
                    meta[key] = dewies_to_lbc(value)
        if 0 < meta.get('creation_height', 0) <= self.ledger.headers.height:
-            meta['creation_timestamp'] = self.ledger.headers[meta['creation_height']]['timestamp']
+            meta['creation_timestamp'] = self.ledger.headers.estimated_timestamp(meta['creation_height'])
        return meta
    def encode_input(self, txi):
@ -250,7 +267,8 @@ class JSONResponseEncoder(JSONEncoder):
        result['is_default'] = self.ledger.accounts[0] == account
        return result
-    def encode_wallet(self, wallet):
+    @staticmethod
    def encode_wallet(wallet):
        return {
            'id': wallet.id,
            'name': wallet.name
@ -260,26 +278,32 @@ class JSONResponseEncoder(JSONEncoder):
        output_exists = managed_stream.output_file_exists
        tx_height = managed_stream.stream_claim_info.height
        best_height = self.ledger.headers.height
-        return {
+        is_stream = hasattr(managed_stream, 'stream_hash')
-            'streaming_url': managed_stream.stream_url,
+        if is_stream:
            total_bytes_lower_bound = managed_stream.descriptor.lower_bound_decrypted_length()
            total_bytes = managed_stream.descriptor.upper_bound_decrypted_length()
        else:
            total_bytes_lower_bound = total_bytes = managed_stream.torrent_length
        result = {
            'streaming_url': None,
            'completed': managed_stream.completed,
-            'file_name': managed_stream.file_name if output_exists else None,
+            'file_name': None,
-            'download_directory': managed_stream.download_directory if output_exists else None,
+            'download_directory': None,
-            'download_path': managed_stream.full_path if output_exists else None,
+            'download_path': None,
            'points_paid': 0.0,
            'stopped': not managed_stream.running,
-            'stream_hash': managed_stream.stream_hash,
+            'stream_hash': None,
-            'stream_name': managed_stream.descriptor.stream_name,
+            'stream_name': None,
-            'suggested_file_name': managed_stream.descriptor.suggested_file_name,
+            'suggested_file_name': None,
-            'sd_hash': managed_stream.descriptor.sd_hash,
+            'sd_hash': None,
-            'mime_type': managed_stream.mime_type,
+            'mime_type': None,
-            'key': managed_stream.descriptor.key,
+            'key': None,
-            'total_bytes_lower_bound': managed_stream.descriptor.lower_bound_decrypted_length(),
+            'total_bytes_lower_bound': total_bytes_lower_bound,
-            'total_bytes': managed_stream.descriptor.upper_bound_decrypted_length(),
+            'total_bytes': total_bytes,
            'written_bytes': managed_stream.written_bytes,
-            'blobs_completed': managed_stream.blobs_completed,
+            'blobs_completed': None,
-            'blobs_in_stream': managed_stream.blobs_in_stream,
+            'blobs_in_stream': None,
-            'blobs_remaining': managed_stream.blobs_remaining,
+            'blobs_remaining': None,
            'status': managed_stream.status,
            'claim_id': managed_stream.claim_id,
            'txid': managed_stream.txid,
@ -295,8 +319,38 @@ class JSONResponseEncoder(JSONEncoder):
            'added_on': managed_stream.added_on,
            'height': tx_height,
            'confirmations': (best_height + 1) - tx_height if tx_height > 0 else tx_height,
-            'timestamp': self.ledger.headers[tx_height]['timestamp'] if 0 < tx_height <= best_height else None
+            'timestamp': self.ledger.headers.estimated_timestamp(tx_height),
            'is_fully_reflected': False,
            'reflector_progress': False,
            'uploading_to_reflector': False
        }
        if is_stream:
            result.update({
                'streaming_url': managed_stream.stream_url,
                'stream_hash': managed_stream.stream_hash,
                'stream_name': managed_stream.stream_name,
                'suggested_file_name': managed_stream.suggested_file_name,
                'sd_hash': managed_stream.descriptor.sd_hash,
                'mime_type': managed_stream.mime_type,
                'key': managed_stream.descriptor.key,
                'blobs_completed': managed_stream.blobs_completed,
                'blobs_in_stream': managed_stream.blobs_in_stream,
                'blobs_remaining': managed_stream.blobs_remaining,
                'is_fully_reflected': managed_stream.is_fully_reflected,
                'reflector_progress': managed_stream.reflector_progress,
                'uploading_to_reflector': managed_stream.uploading_to_reflector
            })
        else:
            result.update({
                'streaming_url': f'file://{managed_stream.full_path}',
            })
        if output_exists:
            result.update({
                'file_name': managed_stream.file_name,
                'download_directory': managed_stream.download_directory,
                'download_path': managed_stream.full_path,
            })
        return result
    def encode_claim(self, claim):
        encoded = getattr(claim, claim.claim_type).to_dict()
--- a/lbry/extras/daemon/migrator/init.py
+++ b/lbry/extras/daemon/migrator/init.py
--- a/lbry/lbry/extras/daemon/migrator/dbmigrator.py
+++ b/lbry/lbry/extras/daemon/migrator/dbmigrator.py
@ -35,6 +35,10 @@ def migrate_db(conf, start, end):
            from .migrate12to13 import do_migration
        elif current == 13:
            from .migrate13to14 import do_migration
        elif current == 14:
            from .migrate14to15 import do_migration
        elif current == 15:
            from .migrate15to16 import do_migration
        else:
            raise Exception(f"DB migration of version {current} to {current+1} is not available")
        try:
--- a/lbry/lbry/extras/daemon/migrator/migrate10to11.py
+++ b/lbry/lbry/extras/daemon/migrator/migrate10to11.py
--- a/lbry/lbry/extras/daemon/migrator/migrate11to12.py
+++ b/lbry/lbry/extras/daemon/migrator/migrate11to12.py
--- a/lbry/lbry/extras/daemon/migrator/migrate12to13.py
+++ b/lbry/lbry/extras/daemon/migrator/migrate12to13.py
@ -65,7 +65,7 @@ def do_migration(conf):
                added_on
            from file;
-        insert into new_content_claim (stream_hash, bt_infohash, claim_outpoint)
+        insert or ignore into new_content_claim (stream_hash, bt_infohash, claim_outpoint)
            select stream_hash, NULL, claim_outpoint from content_claim;
        drop table file;
--- a/lbry/lbry/extras/daemon/migrator/migrate13to14.py
+++ b/lbry/lbry/extras/daemon/migrator/migrate13to14.py
--- a/lbry/extras/daemon/migrator/migrate14to15.py
+++ b/lbry/extras/daemon/migrator/migrate14to15.py
@ -0,0 +1,16 @@
 import os
 import sqlite3
 def do_migration(conf):
    db_path = os.path.join(conf.data_dir, "lbrynet.sqlite")
    connection = sqlite3.connect(db_path)
    cursor = connection.cursor()
    cursor.executescript("""
        alter table blob add column added_on integer not null default 0;
        alter table blob add column is_mine integer not null default 1;
    """)
    connection.commit()
    connection.close()
--- a/Show more
+++ b/Show more
		`@ -0,0 +1,2 @@`
							`__version__ = "0.113.0"`
							`version = tuple(map(int, __version__.split('.'))) # pylint: disable=invalid-name`